Recurrent Adversarial Service Times

TL;DR

This paper introduces a deep learning approach combining recurrent neural networks and generative adversarial networks to model customer arrivals and service times in queuing systems, overcoming parametric limitations of traditional methods.

Contribution

It presents a novel neural network framework that jointly models arrival processes and service time distributions without restrictive parametric assumptions.

Findings

Effective modeling of diverse empirical datasets

Outperforms traditional parametric models

Applicable to internet and mobility service systems

Abstract

Service system dynamics occur at the interplay between customer behaviour and a service provider's response. This kind of dynamics can effectively be modeled within the framework of queuing theory where customers' arrivals are described by point process models. However, these approaches are limited by parametric assumptions as to, for example, inter-event time distributions. In this paper, we address these limitations and propose a novel, deep neural network solution to the queuing problem. Our solution combines a recurrent neural network that models the arrival process with a recurrent generative adversarial network which models the service time distribution. We evaluate our methodology on various empirical datasets ranging from internet services (Blockchain, GitHub, Stackoverflow) to mobility service systems (New York taxi cab).

Tables

Table 1. Table 1 . Main results on synthetic datasets.

	NH-PT		NH-PS		H-PT		H-PS
mean	0.052		0.0004		0.0061		2.125e-5
	error	KS	error	KS	error	KS	error	KS
NS-G	0.207	0.218	0.020	0.520	0.254	0.879	2.18e-5	0.401
NS-E	0.209	0.154	0.0006	0.082	0.432	0.979	3.06e-5	0.501
NS-P	0.210	0.330	0.0007	0.610	0.443	0.981	2.09e-5	0.501
NS-C	0.372	0.242	0.061	0.527	0.037	0.988	0.029	0.511
NS-L	5.293	0.525	6.158	0.479	4.282	0.971	8.500	0.555
AS	0.215	0.113	0.0016	0.448	0.250	0.235	1.24e-4	0.121
RAS-NH	0.218	0.124	0.0031	0.062	0.249	0.222	1.37e-4	0.136
RAS	0.207	0.094	0.0005	0.042	0.242	0.212	1.09e-4	0.110

Table 2. Table 2 . Main results on empirical data-sets.

	Github		NY		Stackoverflow
mean	0.0113		0.0068		0.0193
	error	KS	error	KS	error	KS
NS-G	0.073	0.396	0.025	0.154	0.378	0.480
NS-E	0.074	0.458	0.007	0.251	0.379	0.509
NS-P	0.071	0.604	0.008	0.367	0.378	0.466
NS-C	0.096	0.341	0.182	0.632	0.403	0.533
NS-L	6.37	0.496	0.155	0.627	15.93	0.595
AS	0.071	0.039	0.006	0.094	0.383	0.226
RAS-NH	0.112	0.240	0.098	0.165	0.388	0.492
RAS	0.072	0.034	0.005	0.030	0.369	0.281

Table 3. Table 3 . Mempool dataset results.

	Unconfirmed Transactions		Departures
mean	0.2484		0.2159
	error	KS	error	KS
P	0.2513	0.2417	0.1173	0.2781
L	0.2687	0.2527	0.1173	0.4760
G	0.1948	0.2550	0.1173	0.4760
NMS-G	0.1725	0.1472	0.3080	0.2481
AMS	0.0271	0.0236	0.0016	0.0290

Equations

$$f^{\ast }(t)={\lambda }^{\ast }(t)\exp \left\{{\int }_{a_j}^t{\lambda }^{\ast }\left(t^{\prime }\right)d{t}^{\prime }\right\},$$

$${\lambda }^{\ast }(t)=\exp \left\{{\mathbf{v}}^t\cdot {\mathbf{h}}_j+w^t\left(t-a_j\right)+b^t\right\}.$$

$$\text{raggedleft}{f}^{\ast }(t)\text{@add@raggedleft}$$

$$\exp \left\{-{\int }_{a_j}^{a_j+\tau }\lambda (t)dt\right\}={\int }_{\tau }^{\infty }P(T|{\mathcal{H}}_j)dT\equiv G(\tau ),$$

$$G(\tau )=\exp \left\{-e^{{\alpha }_j}\frac{1}{w^t}\left(e^{w^t\tau }-1\right)\right\},$$

$$\mathbb{E}[T]={\int }_0^{\infty }P(T|{\mathcal{H}}_j)TdT={\int }_0^{\infty }G(T)dT.$$

$$F[P(T|{\mathcal{H}}_j)]={\int }_0^{\tau }P(T|{\mathcal{H}}_j)dT=-{\int }_0^{\tau }\frac{dG(T)}{dT}dT=G(0)-G(\tau )$$

$$F^{-1}[P(T|{\mathcal{H}}_j)](y)=\frac{1}{w^t}\left(-{\alpha }_j+\log \left\{w^t\left(\log \left\{\frac{-1}{y-1}\right\}+\frac{e^{{\alpha }_j}}{w^t}\right)\right\}\right).$$

$$s_i\sim {\Phi }_{\theta }(s|{\mathbf{h}}_i^a,{\mathbf{x}}_i),$$

$$\bar{\Phi }(s_i)={\int }_{T_i}^{\infty }{\Phi }_{\theta }\left(\tau |,{\mathbf{h}}_i^a,{\mathbf{x}}_i\right)d\tau .$$

$${\mathcal{L}}_s=\sum _{\mathcal{D}}\log \left\{{\Phi }_{\theta }\left(s_i|{\mathbf{h}}_i^a,{\mathbf{x}}_i\right)\right\}+\sum _{\mathcal{C}}\log \left\{\bar{\Phi }\left(s_i\right)\right\}.$$

$$s_i={\Phi }_{\theta }(s|ϵ,{\mathbf{h}}_i^a,{\mathbf{x}}_i),ϵ\sim {\mathbb{P}}_{ϵ}\text{mbox}.$$

$$\mathcal{L}=\underset{\theta }{\text{mbox}min}\underset{f_{\phi }\in {\mathfrak{L}}_1}{\text{mbox}max}{\mathbb{E}}_{s\sim {\mathbb{P}}_{\mathcal{D}}}\left[f_{\phi }(s)\right]-{\mathbb{E}}_{s\sim {\mathbb{P}}_{\theta }}\left[f_{\phi }(s)\right],$$

$${\mathcal{L}}_1={\mathbb{E}}_{s\sim {\mathbb{P}}_i}\left[{\left(\text{mbox}max\left\{0,|{\nabla }_s{f}_{\phi }(s)|-1\right\}\right)}^2\right],$$

$${\mathcal{L}}_2={\mathbb{E}}_{\mathbf{x}\sim {\mathbb{P}}_{\mathcal{C}},ϵ\sim {\mathbb{P}}_{ϵ}}\left[\text{mbox}max\left\{0,T-{\Phi }_{\theta }(s|ϵ,{\mathbf{h}}^a,\mathbf{x})\right\}\right].$$

$${\mathcal{L}}_3={\mathbb{E}}_{ϵ\sim {\mathbb{P}}_{ϵ},(\tilde{s},\mathbf{x})\sim {\mathbb{P}}_{\mathcal{D}}}\left[\left|\tilde{s}-{\Phi }_{\theta }(s|ϵ,{\mathbf{h}}^a,\mathbf{x})\right|\right].$$

$${\mathbf{h}}_i^{\Phi }=g_{\theta }({ϵ}_i,{\mathbf{h}}_i^a,{\mathbf{x}}_i,{\mathbf{h}}_{i-1}^{\Phi }),{ϵ}_i\sim {\mathbb{P}}_{ϵ},$$

$$u_{i+1}={\Phi }_{\theta }^U(u|{\mathbf{h}}_i^U),{\mathbf{h}}_i^U=g_{\theta }(ϵ,{\tau }_i,u_i,{\mathbf{h}}_{i-1}^U).$$

$${\lambda }_d^{\ast }\left(t\right)=\exp \{{\mathbf{v}}_M^t\cdot {\mathbf{h}}_j^M+{\mathbf{v}}_U^t\cdot {\mathbf{h}}_j^U+w^t\left(t-d_j\right)+b^t\},$$

$$b_{i+1}={\Phi }_{\varphi }^M(b|ϵ,{\mathbf{h}}_i^M,{\mathbf{h}}_{i-1}^U),$$

Full text

Service Times, Queues, Recurrent Point Processes, Blockchain Mempool, Conditional Adversarial, Wasserstein GANs

††conference: Woodstock ’18: ACM Symposium on Neural Gaze Detection; June 03–05, 2018; Woodstock, NY††booktitle: Woodstock ’18: ACM Symposium on Neural Gaze Detection, June 03–05, 2018, Woodstock, NY††price: 15.00††isbn: 978-1-4503-9999-9/18/06††ccs: Service Times Queues††ccs: Recurrent Point Processes††ccs: Bicoin Blockchain Mempool††ccs: GANs Wasserstein GANs

1. Introduction

The ultimate success of any service provider rests on their ability to quickly and efficiently satisfy their customers: a mobility system is only successful if its users arrive on time; a block-chain is reliable provided that low latency of its transaction times is ensured; Internet services can only retain users if they provide quick and fast response. To operate systems like these, one needs to understand not only when customers will require a service but also how the system is able to react and respond to demands. Moreover, one should be able to dynamically adapt the system to external events. Here, examples include sudden disruptions of the mobility system due to a car crash or weather conditions or financial crises and breaking news affecting block-chain transactions.

Recent research has focused primarily on the customer side of a service system. For instance, research on dynamical recommender systems aims at understanding the change in users’ preferences over time. These changes, together with trends as to the popularity of items, determine suitable recommendations (Wu et al., 2017), (Jing and Smola, 2017), (Zhou et al., 2018). Within this line of research the customer dynamics are analyzed using point process theory and are modeled using parametric forms such as Poisson- or Hawkes processes. However, these parametric forms constrain the model’s expressibility to capture the users’ dynamic behavior. This drawback has lately been tackled by means of flexible non parametric models such as recurrent neural networks and Gaussian processes (Mei and Eisner, 2017a)(Du et al., 2016a).

Another line of research focuses on the service side of the system, in articular on service times. Corresponding approaches typically resort to queuing theory: a customer expresses a demand and the system decides when to serve this demand. Within queuing theory, the customer dynamics is modeled with a point process and, yet again, parametric forms are assumed. Results are usually limited to moments of the service time distribution (Asmussen, 2008) or are, in some cases, based on Bayesian inference (Sutton and Jordan, 2011). Yet, the latter is often neither flexible nor scalable enough to handle millions of customers in modern service systems.

The work presented here aims at combining recurrent neural networks for modeling the customer arrival process with flexible service time distribution models. Our contributions are as follows:

• First deep solutions to service times for queuing systems: to the best of our knowledge, this is the first approach exploiting the representation learning capabilities of deep neural networks for point processes to infer service time distributions. We provide two models: first, distributions parametrized by multilayered perceptrons, and, second, generative adversarial neural networks. The adversarial models successfully capture multi-modal and long tail service time distributions.
• General solutions: our methodologies deliver holistic solutions for general families of arrival and service processes, superior to classical theoretical models which are constrained to some specific aspects of either the arrival or the service process.
• Dynamic services: we introduce solutions which characterize independent service time dynamics thus allowing for exogenous events to be characterized implicitly.
• Bitcoin mempool: to the best of our knowledge, we provide the first deep and non parametric solution for the prediction of unconfirmed transactions and block creations in the Bitcoin network.
• Predicting and sampling from point process: additionally, we provide a new general framework for prediction of- and sampling from recurrent point process models.

Our presentation proceeds as follows: In Section 2 we present the theoretical basis of our models, which are then introduced in Section 3. Section 4 presents extensive empirical evaluations of our approach and Section 5 finally concludes this paper.

2. Background

In this section we introduce the basic concept of queuings and the standard notation of the theory. We also introduce the Recurrent Point Process model (RPP) (Du et al., 2016a), with which we model the customer arrival process and which will serve as a starting point for our service time models. Finally, we provide a new framework for prediction and sampling from the RPP model.

2.1. Queues Notation

The theory of queuings deals with the study of customer’s service times in a system. One would like to know how much time a customer is likely to wait for a service, or how much time this service is expected to last. It corresponds to a central technique in the area of operations research, as it is of fundamental interest to efficiently allocate time and resources in a given service system. Historically, the field emerged from the studies related to telephone exchange and call arrivals.

In order to define a queuing system one must specify the nature of the client arrivals as well as the system server dynamics. One system might allow for a finite amount of clients which can be served at a time, or the service times might dynamically change with every incoming client. In the initial framework, one models the arrivals as a point process, traditionally specifying the inter-arrival time (i.e. the difference between two consecutive arrivals) of this process. In the following we denote the arrival times as a sequence $a_{i}\in\mathbb{R^{+}}$. After arrival, the client waits until the service dynamics chooses to start the corresponding service. This waiting time is denoted as $w_{i}\in\mathbb{R^{+}}$. After the service is completed the client leaves the systems at a departure time, denoted by $d_{i}\in\mathbb{R^{+}}$. These departure times also define a point process, to which we refer in the following as departure process. The service time $s_{i}\in\mathbb{R^{+}}$ is defined as the amount of time the $i$th client spends being served, i.e. $s_{i}=d_{i}-a_{i}$.

The standard notation used to specify the characteristics of the different queuing systems consists of characters separated by slashes: $\cdot/\cdot/\cdot$. The first character describes the arrival process, namely the inter arrival distribution. Typical examples are $M$ for memoryless (Poisson), $D$ for deterministic times and $G$ for general distributions. The second character specifies the service process, i.e. the service time distribution, and the third one specifies the number of servers available in the system. For example, a $M/M/1$ queuing corresponds to a queuing system with Poisson arrivals and exponential distributed service times for a single server.

In this work we provide a general solution to the $G/G/\infty$ queuing problem.

2.2. Recurrent Point Process

In what follows we write the likelihood of a Poisson process induced by an intensity function $\lambda^{*}(t)$ and defined through a recurrent neural network, following the procedure stated in (Mei and Eisner, 2017b), (Du et al., 2016b). Let us consider a point process with a compact support $\mathcal{S}\subset\mathbb{R}$. Formally, the likelihood is written down as an inhomogeneous Poisson process between arrivals conditioned on the history of arrivals $\mathcal{H}_{j}\equiv\{a_{1},...,a_{j}\}$111a.k.a. filtration (Daley and Vere-Jones, 2007). For one-dimensional processes the conditional likelihood function reads

[TABLE]

where $\lambda^{*}$ is (locally) integrable function. The functional dependence of the intensity function is given by a recurrent neural network (RNN) with hidden state $\mathbf{h}_{j}$, where an exponential function guarantees that the intensity is non-negative

[TABLE]

Here the vector $\mathbf{v}^{t}$ and the scalars $w^{t}$ and $b^{t}$ are trainable variables. We remark that although recurrent networks (Graves, 2013) are defined over sequences, the point process likelihood Eq. (1) requires evaluation of the function over the whole support $\mathcal{S}$. In both (Mei and Eisner, 2017b) and (Du et al., 2016b) this problem is bypassed by defining decaying continuous values between two arrivals $a_{j}$ and $a_{j+1}$, either for memory cells in LSTMs or hidden layers.

The update equation for the hidden variables of the recurrent network can be written as a general non-linear function $\mathbf{h}_{j}=f_{\theta}(\mathbf{h}_{j-1},\mathbf{a}_{j})\,$, where $\theta$ denotes the network’s parameters. Performing the integration in Eq. (1) one obtains

[TABLE]

We can learn the model parameters by maximizing the joint model log-likelihood $\mathcal{L}_{\mbox{RPP}}=\sum_{i}\log f^{*}(\delta_{i+1}|\mathbf{h}_{i})$, where $\delta_{i+1}=a_{i+1}-a_{i}$ denotes the inter-arrival time.

2.3. Prediction and Sampling

We start by denoting $P(T|\mathcal{H}_{j})$ as the distribution that the next point arrives at $T$ given the previous history until $a_{j}$ - we require $P(T|\mathcal{H}_{j})$ for both prediction and sampling. First, notice that the probability of no point arriving between $a_{j}$ and $a_{j}+\tau$ can be obtained as an integral over $P(T|\mathcal{H}_{j})$, say

[TABLE]

with $P(T|\mathcal{H}_{j})=-\frac{dG(T)}{dT}$, where we used the Poisson distribution for zero arrivals in the first expression. Solving for $G(\tau)$ we find

[TABLE]

with $\alpha_{j}=\mathbf{v}^{t}\mathbf{h}_{j}+b^{t}$. The average time of the next arrival is then given by

[TABLE]

Finally, in order to sample the next arrival time one can use inverse transform sampling on $P(T)$. To this end one requires the inverse of the cumulative function of $P(T)$. We calculate the cumulative function thus

[TABLE]

whose inverse function then follows

[TABLE]

3. Models: Deep Service Times

In this Section we introduce our models. We start by setting the methodology with some notation common across our different contributions. Consider the $G/G/\infty$ queuing system. For a given observation time window $[0,\,T]$, where $T$ is the maximum observation time, the dataset consists of a series of arrivals $a_{i}$ and associated departures $d_{i}$ each represented in continuous time $\mathbb{R}^{+}$. Additionally, for each arrival we also have a set of covariates $\mathbf{x}_{i}$, upon which we will condition our service time models-these covariates can be taken as scalars or vectors. Now, if for a given $a_{i}$ no departure is observed within the observation window we set $d_{i}=\infty$. Thus we define $\mathcal{D}$ as the set of uncensored events, i.e. the set of arrivals which have departure within our observation time. Accordingly, $\mathcal{C}$ as the set of censored events which have no departure within this window.

Fig. 1 shows an overview of our service time distribution models, which take the hidden state of a trained RPP model as input thus providing a rich representation of the customer arrival dynamics. We provide two methodologies: (i) we propose parametric forms for the service time distribution where the parameters of known service distributions are defined by multilayered perceptrons. We shall refer to these model as neural service (NS-X) models, where the X labels an specific survival distributions (see Section 3.1). This set of models is a natural generalization of classical stationary solutions to the queuing problem (Kingman, 1993) and will serve as our baseline models in what follows; (ii) we propose two adversarial solutions: first, a static one in which the dynamics of the system is encoded only through the arrivals RPP process (AS model). Second, a dynamical model, wherein the adversarial generator encodes the dynamics of the systems service via a non parametric state transition function parametrized by a recurrent neural networks (RAS model).

We will discuss each of these models in detail in Sections 3.1-3.3. Finally in Section 3.4 we focus on a specific problem: the mempool of unconfirmed transactions in the Bitcoin Blockchain transactions network. The dataset for this problem differs from the classical customer arrival process, which instead of being a point process is given as a counting process — the number of unconfirmed Bitcoin transactions.

3.1. Neural Service Times (NS-X)

We start with the customer arrival point process $a_{i}$. We consider the RPP model as defined in Eq. (2) and denote its hidden state representation as $\mathbf{h}_{j}^{a}=g_{\eta}(\mathbf{a}_{j},\mathbf{h}_{j-1}^{a})$, where $\eta$ labels the set of parameters of the RPP network.

To model the distribution of customer service times, we introduce the generative model

[TABLE]

with parameter set $\theta$. This model captures the complicated dependencies in the arrival dynamics $a_{i}$ — encoded through the hidden states $\mathbf{h}^{a}_{i}$, and any other covariates $\mathbf{x}_{i}$ in the system. This conditional form allows our model to leverage the dynamical information of the arrival process. We define $\Phi_{\theta}$ as one of the following five distributions: Gamma (NS-G), Exponential (NS-E), Pareto (NS-P), Chi-square (NS-C) or Log-normal (NS-L), whose parameter set $\mathcal{P}$ are defined via multilayer perceptrons. Thus for the NS-G model we have $s_{i}\sim\mbox{Gamma}(\alpha^{a}_{i},\beta^{a}_{i})$ with $\mathcal{P}=\left[\alpha^{a}_{i},\beta^{a}_{i}\right]=\mbox{MLP}_{\theta}([\mathbf{h}^{a}_{i},\mathbf{x}_{i}])$. The neural service models can then be interpreted as a marked RPP where the marks are continuous and have a dynamical character whose distribution corresponds to that of the service times. We train these models by maximizing the log-likelihood of our generated service times with respect to the uncensored dataset $\mathcal{D}$.

Censored events. To capture censored events we introduce the probability of obtaining an expected remaining service time bigger than the observation window $T_{i}=T-a_{i}$

[TABLE]

The complete log-likelihood of the NS-X model then reads

[TABLE]

The NS-X models are provided with output distributions which are common solutions to stationary distributions for service times in theoretical models (Asmussen, 2008). The NS models are the closest representation to these theoretical estimates, due to the distributional forms of the outputs distribution. Queuing theoretical models, however, cannot capture the censored arrivals, in contrast to the NS-X models. Therefore the NS-X models are a natural extension of the theoretical ones and serves as a baseline to the adversarial models introduced in the next section.

3.2. Adversarial Service Times (AS)

The expressibility of our model is severely constrained by any functional form imposed on $\Phi(s)$. In order to allow for more general service time distributions we consider Generative Adversarial Networks (GAN) (Goodfellow et al., 2014), a class of generative models wherein approximate (service time) samples $s_{i}$ are drawn as

[TABLE]

Here $\mathbb{P}_{\epsilon}$ is a simple distribution, e.g. isotropic Gaussian or uniform distribution, and the generator $\Phi_{\theta}$ is modeled by a deep neural network with parameter set $\theta$, conditioned on both the arrival dynamics and the system’s covariates. In our experiments we define $\Phi_{\theta}$ as a multilayer 222In our experiments, we found that 3 layers provides the best model perceptron and add a noise term drawn from a Gaussian $\mathcal{N}(0,1)$ at each of this layers, as to increase the variance in the samples from $\Phi_{\theta}$ (Chapfuwa et al., 2018).

This class of models is trained by minimizing specific distances (or divergences) between the empirical distribution — here the distribution of uncensored events $\mathbb{P}_{\mathcal{D}}$, and the distribution $\mathbb{P}_{\theta}$ of the generated samples $\{\Phi_{\theta}(s)\}$. Each such distance differs on the impact it has on the convergence of $\mathbb{P}_{\theta}$ towards the empirical distribution, and thus on the training stability. Here we choose to minimize the Wasserstein-1 distance (WGAN) (Arjovsky et al., 2017), which has been shown to be continuous everywhere and differentiable almost everywhere, as opposed to e.g. the Jensen-Shannon divergence minimized in the original GAN formulation.

Using the Kantorovich-Rubinstein duality (Villani, 2009) to compute the Wasserstein-1 distance one can express the WGAN objective function $\mathcal{L}$ as:

[TABLE]

where the maximum is taken over all 1-Lipschitz functions $\mathfrak{L}_{1}$, defined as functions whose gradients have norms at most 1 everywhere (all the functions we consider are sufficiently smooth). Within the WGAN formulation the critic function $f_{\varphi}$ is modeled by a deep neural network with parameter set $\varphi$ and needs to fulfill the Lipschitz constraint. In order to enforce it we follow (Petzka et al., 2018) and add a regularization term of the form

[TABLE]

where $\mathbb{P}_{i}$ is implicitly defined as sampling uniformly along straight lines between pairs of points sampled from the empirical $\mathbb{P}_{\mathcal{D}}$ and the generator $\mathbb{P}_{\theta}$ distributions (Gulrajani et al., 2017). Minimizing Eq. (4) under an optimal critic function with respect to $\theta$ minimizes the Wasserstein distance between $\mathbb{P}_{\mathcal{D}}$ and $\mathbb{P}_{\theta}$ — this defines the adversarial game.

In our experiments the critic is defined as a 3-layer perceptron and is also conditioned on the covariates $f_{\varphi}=f_{\varphi}(s,\mathbf{x})$.

Censored events. To train $\Phi_{\theta}$ to learn the distribution of censored events $\mathbb{P}_{\mathcal{C}}$ we follow (Chapfuwa et al., 2018) and consider a second regularizer which penalizes sampled service times smaller than the censoring time $T$, that is

[TABLE]

We also correct for situations in which the proportions of uncensored events is low through

[TABLE]

Our full objective function reads $\tilde{\mathcal{L}}=\mathcal{L}+\sum\limits_{i=1}^{3}\lambda_{i}\mathcal{L}_{i}$, where $\lambda_{1}=10$ and $\lambda_{3}=1$ throughout all experiments whereas $\lambda_{2}$ changes depending on the datasets (see Section 4.3 for details).

3.3. Recurrent Adversarial Service Time (RAS)

The response of a service system to newly arrived customers intuitively has a dynamic component (e.g. the dynamic reallocation of resources depending on the number of arrivals still on service, the response to past events disrupting the service, etc). In order to capture such a dynamic response and implicitly characterize exogenous events we approximate the system’s transition function with a stochastic recurrent neural network

[TABLE]

where $g_{\theta}$ is a RNN with parameter set $\theta$ and $\mathbf{h}_{i}^{\Phi}$ is the hidden state encoding the independent dynamic character of the service system. The model is informed about the incoming arrival through the hidden state $\mathbf{h}_{i}^{a}$ of the arrival RPP model and the arrival covariates $\mathbf{x}_{i}$. Its noisy component, on the other hand, comes from $\mathbb{P}_{\epsilon}$, an isotropic Gaussian sampled at each arrival time.

We then define the generator $s_{i}=\Phi_{\theta}(s|\mathbf{h}_{i}^{\Phi},\epsilon),\epsilon\sim\mathbb{P}_{\epsilon}$ as a 3-layer perceptron with the RNN’s hidden representation Eq. (5) as input and an additional noise terms $\epsilon$ added in each layer. We train the model by minimizing Eq. (4) together with the regularizers $\mathcal{L}_{i}$ as above. Let us note here that recurrent generative models with adversarial training has been considered before (Mogren, 2016), (Hyland et al., 2018). In our experiments the critic function $f_{\varphi}=f_{\varphi}(s,\mathbf{x}_{i})$ remains static and is defined once more as a 3-layer perceptron.

3.4. Bitcoin Mempool

In the following we modify our approach to analyze data from a specific type of queuing: the transaction queuing of the Bitcoin network. The decentralized currency protocol known as Bitcoin (Nakamoto, 2008) utilizes a peer-to-peer (P2P) architecture that enables users to send and receive transactions, denominated in units of Bitcoin (BTC). Transactions are broadcasted by a Bitcoin client and received by the peer-to-peer network. They are confirmed after having been added to the Blockchain. This data structure contains blocks of all accepted transactions since the genesis of the system. The creation of each block defines a point process which can be understood as a departure process for the transactions, thus encouraging the modelling of the system dynamics as a queuing system. Specifically, we analyze the Bitcoin mempool, the set of unconfirmed transactions $u$ in the Bitcoin network. Here, the creation of a block at time $d_{i}$ generates a sudden drop $b_{i}$ in the number of unconfirmed transactions $u_{i}$ (Fig. 2(a)). The set of unconfirmed transactions plays the role of waiting clients, and the creation of a block specifies the simultaneous departure of many clients (transactions).

We first model the independent dynamics of the number of unconfirmed transaction with the generative model

[TABLE]

Here $g_{\theta}$ is a RNN with parameters $\theta$, $\mathbf{h}^{U}_{i}$ encodes the history of $u_{i}$ and $\tau_{i}$ is shown in Fig. 2(a). We present two approximations to the mempool problem: (i) a parametric one, which we called Neural Meempool Service (NMS-G) for which $\Phi_{\theta}^{U}=\mbox{Gamma}(\alpha^{u}_{i},\beta^{u}_{i})$ with $\left[\alpha^{a}_{i},\beta^{a}_{i}\right]=\mbox{MLP}_{\theta}(\mathbf{h}^{U}_{i})$ and $\epsilon=0$; (ii) and a nonparametric one, which we called Adversarial Mempool Service (AMS), in which $\Phi_{\theta}^{U}$ is given by a 3-layer perceptron and for which $\mathbf{h}^{U}_{i}$ is a now random variable with $\epsilon\sim\mathbb{P}_{\epsilon}=\mathcal{N}(0,1)$ in Eq. (6).

Now, the creation of the blocks which form part of the Blockchain defines a departure process which we describe using a RPP model with intensity function

[TABLE]

where $\mathbf{h}^{U}_{i}$ contains the dynamic information of the unconfirmed transaction process whereas $\mathbf{h}^{M}_{i}=\tilde{g}_{\phi}(b_{i},d_{i},\tilde{\tau}_{i},\mathbf{h}^{M}_{i-1})$, with $\tilde{g}_{\phi}$ a RNN describing the departure dynamics. Finally we introduce a generative model for the accepted transaction thus

[TABLE]

with $\epsilon=0$ and $\Phi^{M}_{\phi}$ a Gamma function in our NMS-G formulation, or $\epsilon\sim\mathcal{N}(0,1)$ and $\Phi^{M}_{\phi}$ a 3-layer perceptron in our nonparametric AMS version. We train the NMS-G model via maximum likelihood and AMS using Eqs. 4 and 3.2; the RPP block-creation model is trained as described in Section 2.2. The complete overview of the mempool models is given in Fig. 2(b).

4. Experiments

In this Section we provide the experimental framework upon which we tested our model. First we introduce the datasets which were used in the experiments. We provide synthetic datasets with established models for both the arrivals and the service processes, as well as empirical datasets - this demonstrates the ability of our approach to handle diverse application areas in an flexible and scalable manner. Finally, we specify the details of the neural networks architectures implemented for the experiments, as well as learning parameters and any other hyperparameters as required in the model specification.

4.1. Synthetic datasets

In order to provide a controlled environment to test the behavior of our methodology we introduce the following datasets for different arrivals and service processes. We consider two different arrival processes: (i) Hawkes Process (HP) (Hawkes and Oakes, 1974), which is a model for self-exciting phenomena where user arrivals increase the probability of other users to arrive. It is widely used as a model for users on internet services as it is able to capture bursty human dynamics and is defined via the following conditional intensity function $\lambda_{H}(t)=\lambda_{0}+\sum_{T_{i}:t>T_{i}}\mu(t-T_{i})$, where $\lambda_{0}$ corresponds to the base intensity and models the exogenous arrival events, and $\mu(t-T_{i})$ is the memory kernel which provides the intensity given by past arrivals $T_{i}$. (ii) Non-linear Hawkes Process: an extension of the Hawkes process that allows for inhibitory behavior through a non-linear function over the history of arrivals $\lambda_{NH}(t)=\phi\left(\lambda_{H}(t)\right)$.

In order to gain intuition into traditional service models, we introduce two service functions definitions: (i) Phase Type Distribution (PT): one decomposes the service as a series of exponential service steps. It is defined with the time taken between the initial state and the absorbing state 333a type of first passage time in a continuous time Markov chain. It can be shown that such phase type distributions can approximate any non-negative continuous distribution. (ii) Processor Sharing Distribution (PS): a queuing model in which the system handles an infinite amount of clients simultaneously but must reallocate resources with each new client arrival or departure. It was introduced by Kleinrock (Kleinrock, 1976) to model computer systems that handle multiple client simultaneously. One can think that each client in the system at any time instantaneously receives $1/U(t)$ service power, where $U(t)$ is the number of unfinished clients (clients in the queuing)(Sutton and Jordan, 2011).

The combinations of the two arrivals and the two service models provide four different synthetic queuing: H-PT, H-PS, NH-PT, NH-PS.

4.2. Empirical datasets

We gathered datasets from a variety of internet services, thus providing an in depth analysis of the temporal patterns of users in different domains.

Stackoverflow: a question-answering platform for programmers. We define the customers arrivals as the point in time when questions are posted by the users of the web page. We define the service time as the elapsed time between a question and its subsequent accepted answer time. This view establishes the ensemble of users which provide answers as the service system. We analyze a total of $2\times 10^{7}$ questions.

Github: The version control repository and internet hosting service. As customers arrivals, we defined the creation of an issue in a given repository. Its departure time is the moment the given issue was closed. Therefore, the set of users associated with a given repository, can be thought of as the service system. We analysed the top (ranked by the number of issues) 500 repositories in the platform in 2015 in total $1.5\times 10^{6}$ different issues.

New York City Taxi Dataset (NY): The dataset contains data of individual taxi trips in New York city. Customers arrivals are defined as starting time of the trip and the departure time is defined as the final time of the trip. Here, the service system is provided by both the taxi providing the service and the transportation network of roads, streets and highways pertaining to the city of New York. 444https://www1.nyc.gov/site/tlc/about/tlc-trip-record-data.page

Mempool: The dataset consist of all unconfirmed transaction in the mempool dataset as observed by one miner for the time period between January 2017 until June 2018. Here, the service system consists of the whole Bitcoin miner network. This is the only dataset which was used for the Bitcoin mempool model and the details of the arrivals and service is provided in the model specification above. 555https://jochen-hoenicke.de/queuing

4.3. Training details

For the purpose of optimizing the neural networks parameters, we use the ADAM stochastic optimization (Kingma and Ba, 2014) method with a learning rate of $10^{-4}$ (except for the neural mempool model where we use $10^{-5}$). We split the data into training and test sets. The test set is defined as $\sim 5\%$ of the time series. For all the arrival models, we used the Gated Recurrent Units (Cho et al., 2014) for the non parametric state transition functions. The dimension of the GRU is 64 for the PS models, 16 for the PT and Github dataset, 128 for the New York dataset and 256 for the Stackoverflow dataset. For the RAS model, LSTMs where used as state transitions in the arrival model. The MLP for the NS model has two hidden layers with 256 dimensions, whereas the adversarial generator and the critic in the AS and RAS model have 3 hidden layers of 100 units. For the mempool dataset, the NMS-G model requires perceptrons with dimension 32 and LSTM units of size 16 for the unconfirmed transactions. For the service model the dimensions of the perceptrons is 32 and for the LSTM it is 62. The AMS model has 20 units for the unconfirmed transactions generator and critic, and 20 units for the transition function. For the service dynamics, the adversarial model required 10 hidden units for the generator and critic and 10 units for the LSTM transitions.

5. Results

In order to quantify our model performance, we focus on two aspects, namely, its predictive capabilities and the ability of the model to uncover rich distributional forms in the service time. We consider the prediction error defined as $1/N\sum_{i}\lvert s_{i}-\langle\tilde{s_{i}}\rangle\rvert$, where $s_{i}$ denotes the empirical value and $\langle\tilde{s_{i}}\rangle$ denotes the prediction obtained by Monte Carlo sampling. To quantify the descriptiveness of the obtained distributional form, we calculate the Kolmogorov-Smirnov (KS) statistics between the empirical and the predictive distribution and also provide Q-Q plots, against the empirical distributions in the test dataset.

The comparison of the different models based on the predictive error and the KS statistics for the synthetic datasets are shown in Table 1; those for the empirical dataset are shown in Table 2. For most datasets, the adversarial solutions (RAS, AS) outperform the neural (NS) baseline models w.r.t. KS values and prediction metric. This shows a clear advantage of these non-parametric solutions. It is important to note that the neural models strongly benefit from the flexible neural network parametrizations of the output distributions. This additional flexibility enhances the predictive power of the theoretical form and provides a fair comparison against the non-parametric adversarial solutions.

Comparing the adversarial solutions against each other, the RAS model outperforms the AS models. This indicates an improvement of the models with the inclusion of independent dynamics for the service time distribution. The RAS-NH corresponds to our RAS model where we removed the customers’ arrivals hidden states dependency from the service time distribution. The difference to the RAS model highlights the importance of providing a dynamical encoding of customers’ dynamics.

The strength of the adversarial solution is more apparent in the distributional forms. Fig. 3 and Fig. 4 show the histograms for our best model against the empirical distribution as well as Q-Q plots of both the best neural model and the best adversarial solution versus the empirical data. The adversarial model captures the short term behavior, as observed, in the upper left corner of the histogram plots. Note that the weakest results correspond to those of the non-linear Hawkes process in the synthetic datasets. These results reveal the inability of the RNPP model to encode non-linear information as mentioned in (Mei and Eisner, 2017b).

In Table 3, we present the results for the mempool model. The adversarial solution clearly outperforms all other models, both in the error and in the distribution shape as stated in the KS statistics. We can see the qualitative behavior of the mempool models in Fig. 5, where we compare the AMS model with the empirical distribution and the neural model (NMS-G). The success of the adversarial model is immediately apparent as it is the only model that captures the multi-modal nature of the mempool dataset distribution.

Finally, we show a direct comparison of the adversarial and the neural distribution obtained by the different models in Fig. 6. Both for the mempool and the Github datasets the higher expressibility of the adversarial solutions is evident as the neural model only provides long tail behavior constrained by the distributions forms of the outputs.

6. Conclusion

In this work, we presented a novel deep non-parametric solution for the service time distributions of queuing systems for general arrival distributions. Our solutions incorporate censoring of service times and rich estimates for complex distributions as well as independent dynamical representations for the service systems dynamics. Our methodologies outperform neural results and reproduce complex distributions for service times, providing richer representations which are able to recover multi-modal and long tail distributions. We also presented a solution particularly tailored to the Bitcoin mempool queuing systems.

Future lines of work include incorporating richer representations for the arrival processes. In mobility systems, for example, the geographic information and user interactions can be encoded through hidden networks of relations. Moreover, one could make the response of the system explicit by providing new remaining service times with each new arrival.