4.1. Software Application

In desktop software applications, when certain application needs the services of another application it invokes the whole application. In smart-phone applications, however, this behavior is more common. In order to facilitate this paradigm in an efficient way, a smart-phone application is usually broken into a set of Activities. Instead of invoking a whole application, a calling application invokes the required activity in the invoked application. In other words, the activity serves as an entry point for the calling application. Broadly speaking, one activity implements one screen in a smart-phone application.

An Android-based smart-phone application was developed to enable the user to interact with the minimarket. The application has 11 activities, we briefly discuss six essential activities of this application.

The Splash-Screen activity is the first activity. When a user opens the application, a splash screen which has the logo of the minimarket appears. The client can proceed to the next activity by tapping anywhere on the screen. The next activity is the Sign-In activity, where the screen prompts the user to fill in his/her personal information: his/her available balance, valid email address and valid password. However, a new unregistered user will be directed to the Sign-Up activity. In this activity, the user can register as a client by creating a new account and entering his/her information on the database of the system. Figure 2a depicts these activities. It is worth noting that only the system administrator can register the user as a provider.

Figure 2

Application screens.

After a successful client authentication in the Sign-In activity, a client is directed to the Client activity (bottom-right screen in Figure 2a). This activity contains an advertisement banner of the products available at the minimarket. Below it, there is a list (card view) where each row in this list is dedicated for a single product. Each row contains the name, picture, price and number of remaining items of one type of products. In addition, that activity has two buttons that allow the user to either add or remove a product from his/her shopping cart. When one of these two buttons is pressed, a variable called ordered_quantity in the database is automatically updated. This variable is used to inform the provider about the exact number of purchased items per product.

The minimarket has six groups of products: Bread, Canned sea-food, Tea, Soup, Canned corn and Potato crisps. These can be changed to other types of products as required by the service provider. All products' information are retrieved from the database in real-time. When the client finishes selecting the items he/she wants to buy, he/she can tap on the shopping-cart button at the bottom-left corner of the screen (Client activity). This, in-turn will move the user to a new activity (shopping-cart activity).

Unlike the Client activity, which displays the information of all products available at the minimarket, the Shopping-cart activity displays a list view (card view). It shows only information about the products that the client selected for purchase. At the bottom of the Shopping-cart activity, there are two buttons: the first one is a button on the left (arrow button), if tapped on, it moves the user to the previous activity (the Client activity), before this action takes place, a warning message appears to warn the client that his/her shopping cart will be emptied. The second button is on the right of the screen, when tapping on it, an Alert Dialog appears showing the total price of the client's order. Once confirmed, the application sends a command to the microcontroller unit (MCU) at the minimarket. The command contains the name and number of each purchased product item. The purpose of this command is to activate the relevant motors, which will in-turn drop the items into the shopping cart. Finally, the application moves to the splash screen and waits for another order to be placed.

A provider must have a record in the database. If a user signs in as a provider, the application authenticates the email and password. If they match the information in the database, the user is granted access to the Provider activity. The screen of this activity consists of three buttons (see upper-left screen in Figure 2b). The first button (add a new product) allows the provider to add the name, number of items, price, product code and picture for a new product item. The second button (edit product) allows the provider to edit the information of any of the added product items. Finally, when the provider taps on the third button (view revenues) he/she can get information about the revenues of the minimarket.

The flowchart of the smart-phone application is illustrated in Figure 3a and 3b, where, P1 and P2 are off-page connectors, i.e., we start at the top of Figure 3a. When P2 is reached (at the bottom of Figure 3a), the flow is transferred to P2 at the top of Figure 3b. Similarly, when P1 is reached in Figure 3b, the flow is transferred to P1 at the top of Figure 3a. As it can be seen in Figure 3a, the application makes three decisions. The first one is to decide whether the user is a client or provider, and the second one is to decide whether the client is located nearby the minimarket or not. The application is able to determine if a user is still logged in (third decision), otherwise, it returns the first activity.

Figure 3

Flowcharts of the Android application.

If the client is local (see Figure 3b), has enough balance and the minimarket has non-zero items, he/she can proceed with his/her shopping. Once the purchase is confirmed, the application directs the MCU to handle the order. It is worth mentioning that if the user has zero-added items, he/she can still proceed and confirm his/her purchase, but no commands will be sent to the microcontroller and the application goes back to the first activity (P1 in Figure 3b).

4.2. Database

A database was used in this project to store users' and products' information. Each user (client or provider) has an entry which contains an ID number, balance, email address and password. A client can enter this information remotely using a secure network connection. A provider, however, has a different entry which, contains an ID, email address and password. Unlike a client's entry, a provider's entry needs to be entered by the system administrator.

Furthermore, the database holds entries for products' information, specifically, each product has an entry which contains its name, picture, price and number of items. Also, the database stores information about the number of purchased items, expenditures per client, and total revenue of the minimarket, from which, analysis and prediction of revenue and expenditures per client can be made to adapt the supply with the demand of customers, to better fit customers' needs and maximize provider's profit.

The database used in this project was implemented using a real-time database (Firebase [13]). This database implementation is based on Nonstructured Query Language (NoSQL) cloud database, which uses a different data structure (e.g., key-value, wide column, graph or document) for storage and retrieval of data in contrast to the traditional tabular approach used in relational databases. The approach adopted by this real-time database makes it scalable and allows some operations to be executed faster.

In addition, the real-time database provides an Application Program Interface (API) that allows the smart-phone application data to be stored on a cloud. The database relies on REpresentational State Transfer (REST) web service architecture. Specifically, it has REST API that uses Hyper Text Transfer Protocol (HTTP) requests to GET, PUT, POST and DELETE data. This architecture uses less bandwidth and thus is more suitable for Internet usage. From a security view point, the real-time database used in this project uses Secure Sockets Layer (SSL) to establish secure and encrypted connections between the smart-phone application and the database.

Contrary to the traditional way of storing data in tables, the data in this real-time database is stored as nodes, each of which has a number of key-value pairs. Three nodes were used: Shopping-Cart node, User node and Products node. The Products node contains the information about each product, whereas the User node contains information about each user and is updated each time a new user registers in the system. The Shopping-Cart node contains information about the products ordered by the client and is automatically deleted when the user logs out. However, for each order made by a client, the date of the order and the amount of client's expenditure per product in that order is retained in the database.

Nested nodes can be used in the database, i.e., a node can have a set of sub-nodes. For example, the Products node has a sub-node that contains automatically-generated IDs of all products in the minimarket. Each ID sub-node has 8 sub-nodes that defines the picture, name, number of items, ordered price, ordered quantity, price, product code and product ID.

4.3. Time-Series Prediction

The minimarket employs machine-learning algorithms to predict customer expenditures. An ANN was used for that purpose. The ANN was used as a prediction model due to its various advantages over other time-series prediction approaches. To illustrate, the architecture of ANN makes it non-linear, thus an ANN can predict non-linear time series. On contrary, classical time-series prediction approaches—e.g., Auto-Regressive Integrated Moving Average (ARIMA)—assume that time series is generated from linear processes, however, this might be incorrect assumption if the actual empirical time series (i.e., obtained from real system) is nonlinear, thus a prediction model based on ANN is more general. Furthermore, ANN is self-adaptive and is driven by the collected data sample which is used to train the prediction model, i.e., given a data sample (inputs and their corresponding outputs) it can be shown that ANN can approximate any continuous function to any desired accuracy, therefore ANNs are considered a universal approximators. Finally, ANN is immune to noisy data and can still provide accurate prediction of new unseen data even if the data sample that was used in training is noisy.

To illustrate the concept, we review the basic architecture of an ANN and show how time-series prediction fits into that, then provide an approach to improve the prediction capabilities. The basic information-processing element in an ANN is the artificial neuron, which can be defined as a set of connected links, each of which has a weight of its own. Say, e.g., that we have a set of inputs {xt−1,xt−2,…,xt−i}, i=1,2,…,ℓ, each of these inputs is associated with a weight. That is, we have a set of weights for the jth neuron, {wij}, j=1,2,…,m. In addition to these inputs, we have a bias value, which can be represented as an input of “+1” with an associated weight of b1. The inputs and the bias values are multiplied by their weights and summed, then fed into the so-called activation function (ψ1(.)) to produce an output. Thus for the jth neuron we have the following output (uj):

Assuming that the input is a time series, we have three layers of neurons (N(ℓ−m−n)), and we need to estimate the output of the series at t from ℓ previous values, then we can write the estimated output (x̂t) as It is common to use linear activation function in the last layer (i.e. ψ3(.)) to avoid distortion in the predicted output [14]. In this project, the rectifier [15] activation function was used in the three layers for efficient computation.

The problem that ANN tries to solve is: given a set of inputs and their corresponding outputs, what are the weights and the bias values of the neurons that define the relationship between the input and the output? This can be formulated as an optimization problem with an appropriate objective function (loss function). Specifically, the mean squared error can represent an objective function. This can be expressed as

where, xt+j is the actual output at t+j, x^t+j is its corresponding estimated output, and n, (n>0) is the number of samples (the set of inputs and their corresponding outputs). In the context of ANN, the process of determining the weights and bias values is usually referred to as training the network, and the samples used for that purpose are called training samples. The weights and bias values that minimize this function can be determined using an optimization algorithm (e.g., RMSprop algorithm [16] which was used in this project because of its fast convergence to the optimal value).

An alternative approach to time-series prediction is ARIMA model. To illustrate, a time series {xt} can be represented as

where, αi and θi are model's parameters, c is a constant and ϵt−i is the error term at t−i, α0=θ0=1. Now, using the Back-Shift (or Lag Operator) Notation [17]), assuming a unit root (1−B) for the polynomial 1−∑i=1p′αiBi, and factorizing, the time series can be expressed as where ϕi is another model parameter obtained after factorization. After combining (5) and (6), and substituting (p=p′−d): Equation (7) defines an ARIMA (p,d,q) model for the time series, where, p is the order of the autoregressive part, d is the degree of first differencing involved – usually taken as d=1 for practical purposes – and q is the order of the moving average part. It can be seen from (4) and (7) that the future value in a time series is assumed to be a linear function of some past observations and random errors. The autocorrelation function (ACF) and the partial autocorrelation function (PACF) of the sample data are usually used to identify the order of the ARIMA model [18] (for other methods, see [14]).

One way to improve the prediction capabilities of a model is to combine both linear and nonlinear models in a hybrid model. For example, combining ARIMA and ANN [14]. Particularly, if we let yt=(1−B)d(xt−c) and et be the residual error at t, then a two-stage model can be used as follows: first, an ARIMA model is used to generate the residual errors, second, an ANN model is used to capture the nonlinear and linear relationships in both the data and residual errors. Thus, the predicted value of yt (ŷt) becomes

Since the minimarket system is able to store customer expenditures and their IDs, a time series of each customer expenditures on weekly basis can be constructed if the customer used to do his/her weekly shopping on specified day of the week. We slightly abuse the notation of the time-series that we used before and use (X) instead of (x), since this notation is common to denote random variables (used later in Section 6). Thus, we can express this time series as X={X0,X1,…,Xt−52,…,Xt−2,Xt−1,Xt,…}, where t is the time in weeks. Thus, Xt is the amount of customer expenditures on week t, Xt−1 is the amount of customer expenditures on week t−1, and Xt−52 is the amount of customer expenditures on the corresponding week before one year of week t. Our aim was to predict the value of Xt given the values of Xt−1, Xt−2, and Xt−52. In the context of ANN, this maps into three inputs (also called features) and one output (also called label).

In order to achieve our time-series prediction aim, we constructed the ANN shown in Figure 4. This network has four inputs (three inputs and one bias value of “+1”) represented by small unfilled circles in the figure. The network also has three layers of neurons; the first two have 64 neurons each, and the output layer has only one neurons. Neurons are represented as big circles and weights/bias values were removed from the figure to keep it simple. The small filled circles in the figure are used to indicate that there are many neurons (i.e., up to 64 neurons). The output of the network is the output of the last neuron (layer 3) in Figure 4.

Figure 4

Fully-connected artificial neural network (ANN).

The ANN was trained as follows (see Figure 5):

1. The data set (samples) was divided into training samples (80%) and validation samples (20%).

2. The training samples were divided into batches of size n selected at random.

3. Each batch is then used to train the network, i.e., solving for the weights/bias values that minimize (3). Then the model parameters (weights/bias values) were updated.

4. For the next batch, the previous model parameters were used as initial values, and the process is repeated for all batches in the training samples; this is called one epoch.

5. The process was repeated for a number of epochs. For each new epoch, the training samples were shuffled and new batches were selected at random from the training samples. Model parameters' values propagated to the next epoch.

6. For each number of completed epochs, the mean absolute error (E=∑j=1k|xj−x̂j|, where k is the number of training samples) was computed.

7. Also, for each number of completed epochs, the mean absolute error (E=∑j=1l|xj−x̂j|, where l is the number of validation samples) was computed and compared with the corresponding training samples' mean absolute error.

8. Training stops automatically if the mean absolute error is less than a predefined threshold value, this is called, early stop.

The number of layers and the number neurons are tunable. The values shown in Figure 4 were sufficient to predict customer expenditures with acceptable accuracy in this project.

Figure 5

Artificial neural network (ANN) flowchart.

5.1. Minimarket Structure

The structure of the minimarket is similar to that of a vending machine. It is a rectangular box made from foam-core boards with six compartments organized in a 2×3 matrix. Each compartment is designed to hold one type of products and is equipped with a coil attached to the back end of the compartment. Product items are placed between the coil turns, i.e., they are interleaved with the wire rings of the coil. The front end of the compartment is open and allows the product to be dropped when the coil rotates. In addition, each compartment has servo motor which controls the number of coil rotations. This was carefully calibrated such that each rotation drops one item of a product. Figure 6 depicts the structure of the minimarket.

Figure 6

Hardware design.

Product items dropped from the aforementioned structure are placed in a robotic shopping cart which uses a dedicated rail to transport customer's purchased items to his/her location (drive-through window).

5.2. Electronic Design

The servo motors in minimarket structure is electronically controlled by a MCU (NodeMCU[19]), which is connected to the user's smart-phone via Wi-Fi (IEEE 802.11) wireless connection. When a client places his/her order, the smart-phone application identifies the product IDs and the number of purchased items of each product then maps this information into row-column pair and number of motor rotations, respectively. Subsequently, the application sends this information to the MCU through its wireless connection.

Another MCU (Arduino Uno[20]) is placed on the shopping cart to control its motors and synchronize its operation with minimarket structure's operations. Particularly, two sensors were implemented; one is an Infra Red (IR) sensor connected to the NodeMCU microcontroller, the other is a Light-Dependent Resistor (LDR) sensor connected to the Arduino Uno microcontroller. The former informs the NodeMCU about the position of the shopping cart, i.e., whether it is at position A (at the minimarket structure) or at position B (at the customer's location). If the shopping cart is at position A, a Light Emitting Diode (LED) is deactivated to indicate that the product items can be dropped into the cart. Once all purchased items are dropped, the LED is activated to indicate that the cart is ready to move to position B. This LED is strategically position in a Line of Sight (LoS) with an on-board LDR sensor. Thus, when activated; the LED triggers the shopping cart to start moving to position B.

The distance between position A and position B was measured and stored in the memory of the on-board Arduino Uno MCU. Given constant preconfigured Direct Current (DC) motor speeds, the on-board MCU computes the time to reach position B, then activates the shopping-cart motors for this period of time.

Finally, when the shopping cart arrives to position B and the client lifts his/her purchased items, he/she can return the shopping cart to position A by pressing an on-board push button, which reverses the direction of rotation of the shopping-cart motors and activate them for the period of time to reach position A.

As it can be seen from the schematic diagram of the NodeMCU microcontroller circuitry (see Figure 7), the micro controller is connected to six servo motors (shown as MG995), each of these servo motors is attached to a unique compartment in the minimarket structure and is responsible for rotating the coil in that compartment.

Figure 7

Microcontroller unit (MCU) circuit diagram.

7.1. Performance Evaluation

We cross-validate the performance measure obtained analytically with that obtained using a simulation model. We show in this section that both results agree and can be used to study the performance of the minimarket under various levels of traffic intensity and various levels of variations in the service time.

A simulation model was created using the R Language [24] to simulate the system presented in Figure 8. Customers arrived according to a Poisson random process (i.e., exponential inter-arrival times), and several values for the traffic intensity were used: {0.25,0.5,0.75,0.85,0.9,0.95} with an average service time of 60 seconds. The standard deviation of the service time was set to zero, i.e., a deterministic service time (i.e., M/D/1). Ten simulation runs were performed for each traffic-intensity value each of which has 108 simulation time steps. The average and standard deviation of the response time for each value of the traffic intensity were reported and plotted in Figure 10 along with the corresponding theoretical average response time obtained using (13). It can be seen from Figure 10 that at low traffic intensity (25%), the average response time is approximately 60 seconds, however, as the traffic intensity increases, the average response time increases. It was reported that at worst case (95% traffic intensity), if customers arrive at the minimarket every 63 seconds on average, then the average response time for each customer is approximately 10 minutes.

Figure 10

M/D/1: effect of variations in traffic intensity.

The Complementary Cumulative Distribution Function (CCDF) for the number of customers in the system (N) is plotted in Figure 11 for traffic intensities near the value of 95%. To illustrate the use of the curves in Figure 11, we see that the probability of having more than 10 customers in the system when the traffic intensity is 90% is approximately 10% (i.e., P(N>10)≈0.1), while the probability of having more than 10 customers in the system when the traffic intensity is 95% is approximately 30% (P(N>10)≈0.3).

Figure 11

Complementary cumulative distribution function (CDF).

We also studied the effect of variations in service time on the average response time, specifically, we let the service time have a Gaussian distribution and used a set of three values for the standard deviation, {0,10,20}, to obtain a trend on how the average response time varies with the increase of standard deviation at worst case (95% traffic intensity). For each value of the standard deviation values we have run the simulation 100 times, 108 time steps each. Figure 12 summarizes the result of these experiments. Obviously, high variation in service times has an adverse effect on system performance, this can be seen from the increase in the average response time as the variance of service time increases.

Figure 12

M/G/1: effect of variations in service time.

Finally, we examined the case of batch customer arrivals. Specifically, we considered a geometrically-distributed batch size with an average size E[H]=α and a parameter 1∕α. That is, P[“abatchcontainshcustomers”]=(1−1∕α)h−1(1∕α), where, h={1,2,…}. Figure 13 illustrates the average response time per customer for various traffic intensities over a range of average batch sizes. The case of very heavy traffic (95%) can be considered as an upper bound. The figure shows that for heavy traffic intensity (90%) and average batch size of four customers, the average customer response time is 2000 seconds (≈ 34 minutes).

Figure 13

M^[H]/D/1: effect of random batch arrivals.

7.2. Prediction of Customer Expenditures

To illustrate the prediction capability of the minimarket, we relied on the average annual expenditure of Jordanian households on groups of commodities and services by size of household (4-3 members) in Jordanian Dinar (JOD), as obtained from the Department of Statistics in Jordan [2] for the year of 2017. Table 1 shows the average weekly expenditure of middle-size (4-3 members) Jordanian households for a group of commodities commonly consumed by Jordanian families. From Table 1 we can estimate the average sum of expenditures for the given six types of products by approximately 26.56 JOD/week.

We mimicked an arbitrary customer expenditures behavior by creating a time series that has an average value of 26.56 JOD/week and several periodic trends during a total period of 5 years. The minimarket system is able to extract such information for each customer from the database. This time series is fed into the ANN shown in Figure 4 to predict customer expenditures.

The ANN was implemented using the Python deep learning library, Keras [25]. An API was used to integrated the library with the R-Language programming environment. The network was trained according to the steps mentioned in Section 4.3. First, the number of epochs that produce sufficient accuracy was determined, then training samples were randomly grouped into batches. Each batch has a size of n=32 samples. The network was trained using different number of epochs and the mean absolute error for the training and validation data were computed and plotted versus the number of epochs. It can be seen in Figure 14 that for epoch values above 100, the error diminishes to small values. Therefore, we trained the ANN using 100 epochs. Second, we used the validation samples (20% of the data set) to validate the predicted values of customer expenditures. The result is shown in Figure 15. We notice that the ANN is capable of predicting weekly customer expenditures with relatively high accuracy.

Figure 14

Relationship between accuracy and number of epochs.

Figure 15

Weekly customer expenditures: predicted using validation samples.