Business chatbots with deep learning technologies: state-of-the-art, taxonomies, and future research directions

Artificial neural network (ANN), also called the neural network, is a mathematical model that imitates the structure and function of a biological neural network to estimate or approximate the nonlinear functional relationship between the network inputs and outputs. An ANN comprises many nodes connected in different ways to convey information. Each non-input node represents a specific output function called the activation function. Each connection (edge) between two nodes represents a weighted value for the signal passing through the connection, equivalent to the ANN memory. We usually divide the neural network into the input, output, and hidden layers according to the input and output positions of the model. The network output varies with the connection mode (network structure), weight values of edges, and activation functions of nodes for accomplishing different tasks.

An instance of a simple neural network is illustrated in Fig. 7. It is a fully connected feed-forward neural network where each neuron in a layer connects to each node in the adjacent layer. Its information flows only in a forward direction (from the input to the hidden to the output layers) without a cycle or loop connection (Schmidhuber 2015). This sample model has one hidden layer with N dimensions, and the operations of the different layers are as follows.where \({\varvec{x}}=\left\{{x}_{0}, {x}_{1}, \dots , {x}_{i}, \dots , {x}_{M-1}\right\} i\in (0, M)\) stands for an M-dimensional input vector, \({\varvec{h}}=\left\{{h}_{0}, {h}_{1}, \dots , {h}_{j}, \dots , {h}_{N-1}\right\} j\in (0, N)\) and \(y\) stand for the hidden layer vector and output of the network, respectively, \({{\varvec{W}}}_{{\varvec{h}}}\) and \({{\varvec{W}}}_{{\varvec{y}}}\) are the weight matrices, \({b}_{h}\) and \({b}_{y}\) are the bias terms in the corresponding layer, and \({\sigma }_{h}\) and \({\sigma }_{y}\) stand for the activation functions that are often Rectified Linear Unit (ReLU), tanh, or sigmoid to calculate a weighted sum of the inputs in the node.

An ANN with few hidden layers is named a shallow neural network and has been explored for decades in the last century (Schmidhuber 2015). In 2006, Hinton et al. (2006) alleviated the local optimal solution problem using pre-training methods using an ANN with seven hidden layers, allowing for deep-layer operations and rekindling people’s attention to deep learning. An ANN with complex neural structures and many network layers is called a Deep Neural Network (DNN). For example, a fully connected neural network with multiple hidden layers is a standard DNN. DNN has dominated ANN applications due to its robust feature extraction and learning ability. The following sections introduce several common DNN variants in business chatbots.

A recurrent neural network (RNN) is an essential branch of deep learning technologies with directed cycles in model memory that can allow the temporal sequence as input. It is particularly specialized in textual data processing to capture the semantic relationship between words, with the information stored in the multidimensional weights of the networks. The rise of chatbots that can “generate” a response also greatly benefits from RNN development. Two primitive types of RNN have the characteristic of using the internal state (memory) stored in the hidden layer unit to process sequences of inputs. Jordan network (Jordan 1986) uses the output of the output layer at a previous time point as one of the inputs in the current hidden layer. Elman network (Elman 1990), a more general RNN, uses the output of the hidden layer at a previous time point as one of the inputs in the current hidden layer. The inputs of the hidden layer distinguish these two networks.

However, simple RNN models often have difficulty obtaining satisfactory results. The gradient vanishing will happen with the gradient exploding in the simple RNN model, which is difficult to solve by adjusting the learning rate or other model parameters. LSTM is an efficient gradient-based method Hochreiter and Schmidhuber (1997) proposed to alleviate the gradient vanishing problem. Compared to simple RNN units, LSTM adds three logic gates (input, forget, and output) to control the input information, long-term memory, and short-term memory. These gates enable the model to solve the gradient vanishing problem so that the learning rate can be set small. GRU (Cho et al. 2014) is another RNN variant similar to LSTM, and its most prominent characteristic is reducing three gates to two (update and reset); hence, the training speed is accelerated. The GRU model can only read in the new input if it empties the existing state. The performances of these two structures are not far apart but are better than those of traditional recurrent units (Chung et al. 2014).

With the efforts of deep learning researchers, RNN has formed various typical structures after multiple iterations. Seq2seq is one of the most groundbreaking and far-reaching designs. It is a general end-to-end model in an encoder-decoder structure proposed by Cho et al. (2014) and Sutskever et al. (2014). As shown in Fig. 8, it comprises two RNNs, an encoder and a decoder. One RNN encodes a sequence of word vectors into a fixed-length vector representation, and the other decodes the representation into another sequence. The units in this model (blue and green squares in Fig. 8) are usually LSTM or GRU. The encoder and decoder are trained jointly to maximize the conditional probability of a target sequence based on the given source sequence (Cho et al. 2014). This kind of design that can generate a response word by word has been widely used in text generation tasks.

Other well-known improvements include the Bi-LSTM design and hierarchical recurrent encoder-decoder (HRED) architecture. Zhou et al. (2016) proposed the Bi-LSTM that could read the input sequence from two directions to utilize the contextual features instead of the one-side information at a specific time. HRED was proposed by Serban et al. (2016) to model the contextual information for dialogue generation. They considered the turn-taking nature of dialogues and added a context encoder based on the Seq2seq structure to encode the temporal features of appeared utterances. This contextual modeling can reduce the computational steps among adjacent sentences and facilitate the propagation of the information and gradients in the network, thus enabling multi-turn conversation.

A convolutional neural network (CNN) is a special neural network that replaces the general matrix multiplication with the convolution operation in at least one network layer (Goodfellow et al. 2016). Inspired by the research findings of the cat and monkey’s visual cortices (Hubel and Wiesel 1959, 1968), Fukushima (1980) proposed a neural network composed of a convolutional and a downsampling layer, and the max-pooling computation approach was further introduced by Weng et al. (1993) for downsampling. A max-pooling layer often follows a convolution layer in modern CNN design. The uniqueness of CNN architecture lies in extracting spatial features through sequential operations in the convolutional and pooling layers, which validly enables the network to cope with two and three-dimensional input data.

Kim (2014) and Zhang and Wallace (2015) developed the TextCNN for sentence classification tasks to adapt the CNN model for text analysis. A simplified illustration is shown in Fig. 9. Each word in the input sentence will be transformed into a vector with word embedding techniques, and the combined matrix represents the whole sentence. Suppose an input sentence comprises N word vectors of D dimensions, an N × D word matrix. The CNN model in Fig. 9 has six filters of three window sizes, each corresponding to two filters with different values to capture distinct information. The window size (note as M) represents the number of word vectors an M × D filter can cover in a convolution operation. Each filter slides along the input matrix to perform convolution operations in the convolutional layer, and the computed (N − M + 1) × 1 vector is passed to the next pooling layer. A pooling operation is essentially a nonlinear form of downsampling that can reduce the dimensions of the received vector. The maximum value will be extracted from the vector for the frequently used max-pooling. In this instance, six values produced by the pooling layer correspond to the convolution and pooling results of six filters; they will be conveyed to a fully connected network to carry out the final calculation.

The capsule neural network (CapsNet) was initially proposed by Sabour et al. (2017) to overcome CNN’s shortcoming that the max-pooling layer could only concentrate on detecting important local features in computer vision applications. Due to the lack of relative positions among the features, CNN models would misidentify an image of a face with disordered features as correct or an oblique real face as wrong in cases where sufficient data samples are unavailable. Hence, Sabour et al. (2017) invented a special neuron called a capsule to replace the max-pooling operation they thought was causing valuable spatial features to be lost. The most distinguishing characteristic of the capsule neuron is it utilizes a vector as the model output to represent the spatial information (the direction of a vector) and probability value (the norm of a vector) of a detected pattern. This design enables the network to intelligently model the intrinsic spatial relationship between a part and a whole, automatically generalizing the learned knowledge to novel viewpoints and reducing the sample size requirement. Similar to CNN, CapsNet has also been applied to textual data mining; it was first adapted by Zhao et al. (2018) for text classification tasks.

The input of a CapsNet model is usually multiple vectors. Figure 10 illustrates a capsule neuron with two input vectors reshaped from the computed results of the convolutional layer in Fig. 9. The affine transformation is first applied to the input vectors (\({{\varvec{v}}}_{1}\) and \({{\varvec{v}}}_{2}\)) to convert the low-dimensional feature vectors into high-dimensional ones (\({{\varvec{v}}}_{1}^{\boldsymbol{^{\prime}}}\) and \({{\varvec{v}}}_{2}^{\boldsymbol{^{\prime}}}\)). Transformed vectors are then computed by weighted sum to calculate a new vector \({\varvec{s}}\). The weights \({c}_{1}\) and \({c}_{2}\) (named coupling coefficients) are determined by the dynamic routing algorithm (Sabour et al. 2017), and the sum of the coupling coefficients equals 1. Finally, vector \({\varvec{s}}\) is processed by a “squashing” operation (the formula is shown in the grey box of Fig. 10) to generate the output vector \({\varvec{v}}\) with the norm between 0 and 1. This value represents the predicted probability of the pattern that the neuron is responsible for detecting.

A graph neural network (GNN) is an optimizable transformation on all attributes of a graph (nodes, edges, global-context) that preserves permutation equivariant architecture (Sanchez-Lengeling et al. 2021). The concept was proposed by Gori et al. (2005) and further elaborated by Scarselli et al. (2009). GNN adopts a “graph-in, graph-out” architecture, as shown in Fig. 11. Its input is a graph with feature information loaded into its nodes, edges, and global context, and the model progressively transforms these embeddings without changing the connectivity of the input graph.

In a business chatbot, GNN is usually associated with a knowledge graph, a semantic network that can provide additional domain knowledge and assist chatbots in downstream decision-making. A knowledge graph represents a network of entities (nodes) and illustrates their relationships (edges). The entity can be any object, event, situation, or abstract concept. Each node has its attributes. For example, Fig. 12 presents a product knowledge graph Lin et al. (2021a) used for beauty shops. Take the node Product 2 and its relations as an example. It connects two nodes, the entities Ingredient 1 and Flavor 1, through the relations has_ingredient and has_flavor, respectively. Its attributes include title and description in this knowledge graph.

GNN is adopted to process such a graph structure as input and produce new representations embedded with graph information for nodes or edges. Usually, the graph can be modeled as G = (V, E), where V is the node set and E is the edge set. U is the global-context set, such as the number of nodes and edges. The corresponding feature representations of the nodes, edges, and global contexts in the GNN’s n-th layer are V_n, E_n, and U_n. The product knowledge graph in Fig. 12 illustrates the entity attribute information, and thus, the node feature matrix V_n can be considered here. For node i, the GNN’s n-th layer updates its feature representation from V_i.n to V_i.n+1, aggregating information from its attributes and immediate neighbors with a specific optimizable transformation method. Zhou et al. (2020) have summarized existing optimizable transformation methods, mainly including the convolution operator, recurrent operator, skip connection, etc. The updated feature representations of all nodes V_n+1 will be passed to the next layer n + 1, and outputs of the GNN’s final layer are new node representations that can be further used for downstream tasks. After GNN’s iterative processing, the representations for nodes have integrated with the whole graph information.

The generative adversarial network (GAN) is a fascinating semi-supervised learning framework that Goodfellow et al. (2014) proposed for estimating generative models. It is widely used in computer vision to generate new image samples initially. It comprises two sub-models: a generative model (generator) to approximate the data distribution and a discriminative model (discriminator) to estimate the probability that a sample came from the real data rather than the generative model. These two parts are trained simultaneously in the form of a minimax two-player game, and the training procedure for the generator is to maximize the probability of the discriminator making a mistake.

Seq2seq-based artifacts are the most common generative model for text generation. However, they suffer from a severe problem in that the generative model tends to produce a safe response (Zhang et al. 2018b) without practical significance, such as “I don’t know” or “I think so.” The main reason comes from the effects of many safe answers in the training corpus, with many responses starting with “I.” The probability distribution of words in different sentence positions has an apparent long tail characteristic. Hence, the decoder would be affected to select the most probable “I” as the first word of the response, further affecting the generation of subsequent words. The appearance of a safe response implies that the Seq2seq model is trapped in a locally optimal solution. A feasible operation is to impose a disturbance, such as GAN, on the model to make it jump out of the local solution and enter a more optimal global state, thus alleviating the problem.

Figure 13 briefly illustrates a response generation model implemented in a GAN schema with the Seq2seq model as the generator and another neural network as the discriminator. The generator outputs a generated utterance based on the received input that might be processed in some noises or interferences (if any), such as masking some words of the input utterance (Fedus et al. 2018), to increase the conversation variety. The discriminator is responsible for judging the gap between the generated text and the real one and transmitting the computed loss to update the generator parameters. The upgrade of this powerful framework owes much to the work of some researchers who contributed to migrating the GAN mechanism from image creation to text generation. Kusner and Hernández-Lobato (2016) introduced the Gumbel-softmax distribution for the generator to handle the discrete sequence data generation problem. Zhang et al. (2016) designed the textGAN model with a feature distribution matching method to solve a similar text generation problem, and they further improved the objective function with a kernelized discrepancy metric to ameliorate the mode-collapsing problem in GAN’s training process (Zhang et al. 2017). In addition, Yu et al. (2017) and Guo et al. (2018) proposed the SeqGAN and LeakGAN models to optimize the generative performance of long text with policy gradient-based reinforcement learning. These GAN-based models have a prominent characteristic of generating from text to text with a similar structure, which brings the models the potential to solve data paucity problems. They can enhance the original data by this kind of text retelling and improve the robustness of unknown data by data augmentation from the generative model.

Deep reinforcement learning (DRL) refers to a series of algorithms that blend deep learning with reinforcement learning to optimize objective functions and make better decisions in sequential decision problems. Reinforcement learning is a cyclic process in which an agent takes actions according to explicit or implicit policies and then interacts with the environment to gain a reward and change its perceived state. It is designed to maximize the cumulative reward (formulated as the objective function) and settle the decision optimization problem. The distinct characteristic is to consider long-term income through frequent sequential interactions in a trial-and-error mechanism.

The reinforcement learning environment was initially abstracted as a Markov Decision Process (MDP) and solved with the dynamic programming method (Otterlo and Wiering 2012; Bellman 1954). It required much computation time and space to figure out the state transition process and caused the algorithm development to stagnate. The renaissance primarily comes from an event where a computer Go program, AlphaGo, won the Go world champion Fan Hui without handicap on a full-sized 19 × 19 board in 2015. AlphaGo was deployed with the DRL that united function approximation and objective optimization. It leveraged the deep learning perceptual ability to retain the state transition and modeled the policy and objective function of reinforcement learning. The program leader, David Sliver, was thus written into history as the pioneer of DRL, and the achievement has been published in Nature (Mnih et al. 2015; Silver et al. 2016).

A typical DRL process is shown in Fig. 14. Regarding the environment observed at time step t, the agent constructs a perceived state \({S}_{t}\) and follows a value-based or a policy-based method to map from the state to an action \({A}_{t}\). Then, the environment reacts to the agent’s action with a scalar reward \({R}_{t}\). The agent receives feedback from the environment and updates its perception into a new state \({S}_{t+1}\). Deep learning is leveraged to capture complicated relationships among the state, the agent action, and the reward or objective function for action determination and policy learning.

The agent built with a value-based method can utilize deep learning models to simulate a value function that estimates the cumulative reward. It selects the response action of the highest value, and one classical DRL algorithm is Deep Q-Network (DQN) developed by DeepMind (Mnih et al. 2015). The policy-based methods, such as Policy Gradients (Sutton et al. 2000), compute a probability distribution over actions according to the learned policy (represented by network parameters), so every action is likely to be chosen and is especially applicable to the scenario with a continuous action space. To sum up, DRL combines the perceptual ability of deep learning and the decision-making ability of reinforcement learning to define a decision problem and optimize the objective function in consideration of long-term benefits. Serban et al. (2017) adopted it in a social bot design with the dialogue process as state and the candidate response as action to improve users’ multi-round interactive experience. Their Amazon Alexa Prize winning highlights DRL's feasibility in conversation systems.

Transformer is an astonishing deep learning architecture initially proposed by a team from Google Brain (Vaswani et al. 2017) to accomplish machine translation tasks. It has been extended to various AI applications and is widely used to handle sequential data. Concerning traditional deep learning technologies for processing sequence data, the convolutional operation makes CNN essentially a type of local encoding of n-gram models, limiting the network’s capability to establish long-range dependencies. And though the recurrent structure of RNN can capture long sequence information, it is challenging to run in parallel, often costing a tremendous amount of time. To process an entire sentence parallelly and globally, Vaswani et al. (2017) intensively used the self-attention mechanism, a weighted average method to extract key features and fuse the focal information, to design the Transformer model of the encoder-decoder structure.

The general process of the transformer architecture is shown in Fig. 15. With receiving the vector representation of a whole sentence, the transformer model encodes the positional information into it to form the model input. The transformer encoder consists of six identical blocks whose operations are shown on the far left of Fig. 15. Each block includes a multi-head self-attention layer and a position-wise fully connected feed-forward layer. The multi-head self-attention comprises multiple self-attention sub-layers that share the same input. They can relate different positions of a single sequence using the transformation and operation of three matrices, V, K, and Q. For each self-attention, V, K, and Q are derived from three different linear transformations of the same source, designed to capture the relationships between the input information.

When it comes to the transformer decoder, its structure is very similar to the encoder’s, also consisting of six identical blocks, as shown on the far right of Fig. 15. The most significant difference is that each block in the decoder has two multi-head self-attention layers. And they are both slightly differentiated from those in the encoder. The first layer's input matrix is partially masked to prevent positions from attending to subsequent positions. For example, Fig. 15 illustrates the information state at a certain moment during the transformer training process, where the transformer model generates the word “doing” based on the input utterance “How is it going?” and the generated contents “I am” only. The masking operation in the first multi-head self-attention layer ensures that the decoder block cannot utilize the contents that will be produced. For the second layer, its matrices V and K are computed from the encoder output, while the matrix Q is derived from a previous layer in the block. The decoder with six identical blocks is required to capture the information extracted by the encoder and the contents produced by itself before the current moment.

A burgeoning paradigm of pre-training and fine-tuning in recent years further intensifies the propagation of transformer architecture. Fine-tuning is a common transfer learning method that partially adapts a model pre-trained on a large scale of datasets for a new scenario with similar data characteristics. It is particularly beneficial when the data volume is limited to prevent overfitting or in an application where the data amount is enormous to accelerate the model training process. In most cases, the success of a text-related task largely depends on the semantic feature mining from the given corpus. A model pre-trained on a large number of corpora can facilitate efficient text feature extraction by fine-tuning operations for transfer to new applications. Two well-acknowledged pre-trained transformer techniques are the Bi-directional Encoder Representations from Transformers (BERT) and Generative Pre-trained Transformer (GPT). The more commonly used former proposed by Devlin et al. (2019) from the Google AI team is a bi-directional language model based on the transformer encoder structure, while the other provided by OpenAI (Radford et al. 2018) is essentially a transformer decoder that adopts the masked self-attention and can only embed one-side information for a word in the sentence. They are trained on massive unlabeled datasets and can be fine-tuned for various applications without extensive modifications to the specific architecture required for a given task.

Pre-processing is a series of adjustment operations to convert natural language text into an analyzable and predictable computer language form, including spelling correction, tokenization, stop word removal, word normalization, and text vectorization (word embedding). Traditional pre-processing technologies are based on the intuitive understanding of human languages and statistical learning methods (Johnson 2009). For computer processing, designers would program to split the words, remove the unimportant high-frequency terms, convert words to lowercase, change parts of speech, and conduct many other operations. The texts are eventually mapped to vector representations through bag-of-words or n-gram statistical language models before further NLU or NLG processing. This process of vector representation of words is called word embedding. However, not all tasks require the same level of pre-processing operations, and previous methods might ignore the order of words, part-of-speech, and synonyms, resulting in a massive loss of information. The current increase in deep learning technologies provides more options for the word embedding process of NLP. Novel text vector representation techniques in neural network structure reduce the tedious step-by-step pre-processing, replace the traditional statistical learning methods, and overcome the strict demand of statistical learning for elaborate feature engineering. The performance of chatbots has benefitted from the leap in deep learning. It has improved significantly from the pre-processing stage by capturing more information from human language, which further promotes chatbot upgrading. The following contents elaborate on how developers choose deep learning to pre-process received input texts for dialogue systems in consideration of development requirements and technical features.

One typical neural network embedding technology is Word2vec, proposed by Mikolov et al. (2013). It is a group of techniques that builds a standard neural network structure model to reconstruct linguistic word texts and detect synonymous words or suggest additional words for a partial sentence. The by-products of the Word2vec model are used to generate word vectors. The essence of this technology is to reduce dimensions for the one-hot vector of a word through the parameters of the input or output layer of a shallow, double-layer neural network, which significantly improves the performance of computing continuous vector representations of words from huge datasets. Many business chatbots adopted this technology as the standard pre-processing of text vectorization for the received user input, such as customer service support chatbots on Tweet (Aleedy et al. 2019) or in call centers (Xue et al. 2019), a train ticket trading system (Prasomphan 2019a), and an online stock information provider (Jiao 2020). Other technologies, such as GloVe developed by Pennington et al. (2014) at Stanford and fastText offered by Facebook’s AI Research lab (Bojanowski et al. 2017), apply a similar standard neural network structure while exploring more relationships among words. GloVe considers the global word-word co-occurrence statistics of the training corpus for word embedding, in which the distance between words implies more semantic information. This technology has been utilized in common chatbots devoted to customer support services on social media for marketing needs (Hardalov et al. 2019; Kushwaha and Kar 2020). FastText aggregates the n-gram model for word order information representation and the subword model (a text processing method between word and character levels) for atomic unit segmentation of word vectors. Its feasibility has been tested under e-commerce scenarios, such as the commercial telco platform (Ferrod et al. 2021) and the online food delivery company (Brahma et al. 2021).

The convolutional and pooling operations allow CNN to perform well in dealing with two-dimensional data. At the same time, some researchers have attempted to adapt the structure for the one-dimensional convolutional model to extract text features. For instance, Chen et al. (2019) combined CNN with attention and gate mechanisms to extract product review features and encode product-related questions in an e-commerce application. Liu et al. (2020) used a similar technique to learn the dialogue sequence representation. In other customer service scenarios, such as hotel and restaurant consulting, developers (He et al. 2019; He and Tang 2021) have also attempted to use CNN to encode conversation information. In particular, CNN can produce embedded information at the character level. This advantage of CNN is conducive to solving the out-of-vocabulary problem. One well-accepted technique is Char-CNN proposed by Zhang et al. (2015), and Quan et al. (2018) used it to process dialogue information of a chatbot built for the real estate industry.

RNN and its variants, such as LSTM and GRU, are created to handle sequence data, which is naturally suitable for dialogue information processing as human languages are sequential. The internal state (memory) structure can help the system learn the nonlinear features of input sentences, integrate the order of words, and process variable-length sequences, which solves the polysemy problem, earning the interest of many dialogue system developers. In Word2vec, the order of words is not emphasized under the assumption of the bag-of-words model, but it is crucial in the temporal dynamic recurrent network. Because of the powerful text parsing performance of the Seq2seq (encoder-decoder) structure, encoders with different processing units are widely used for sentence embedding. Bartl and Spanakis (2017) and Kushwaha and Kar (2020) used the RNN encoder to extract context features and embed dialogues to build customer service supporting social media chatbots. Primitive encoders only encoded the sentence in a fixed order, sequentially or reversely, to process the text word by word. The improved RNN techniques with the bi-directional structure have proved more effective (Zhou et al. 2016) and have been extensively used in NLP. ELMo (Peters et al. 2018) is one of the representative bi-directional language models to create contextualized word embedding. This architecture can capture more text features by reading the input sentence from two directions, which means the content before and after a word can be processed simultaneously. Variants such as Bi-LSTM and Bi-GRU are common for the dialogue embedding in auto-response applications, including the service industry (Quan et al. 2018; Ren et al. 2020) and e-commerce platform (Kulkarni et al. 2019).

The essence of neural network embedding technologies is to leverage the network structure characteristics to explore the relationships between words in a given text. Each network can extract distinct text features, although not necessarily effective. A hybrid method might be feasible for complex text processing to capture multiple text features. For example, CNN is good at dealing with image data but did not improve much when representing one-dimensional text information. However, when combined with RNN, it can help integrate various extracted text features. Moirangthem et al. (2018) introduced a hybrid of CNN and GRU and evaluated its performance in modeling longer semantic sequences. Prasomphan (2019b) combined CNN with RNN to extract the underlying abstract features of data for dialogue representation in an online sales assistant application system. Ren et al. (2020) adopted a similar method to extract n-gram features from conversations and learn the synergic representation in a restaurant conversational recommender system.

Since the proposal of transformer architecture by the team from Google Brain (Vaswani et al. 2017), its astonishing performance in handling sequential data has induced a boom in replacing RNN-based models to achieve various NLP tasks, even extending to other research fields, such as computer vision. The full use of the encoder-decoder structure and self-attention mechanism makes it more efficient for transformers to process a sentence parallelly and globally than RNN models with a word-by-word mode. Transformer embedding can provide each text input word vector with the global position and context information. BERT and GPT are the most frequently mentioned transformer embedding techniques in up-to-date business chatbots. They have attracted considerable attention in the latest chatbot design and have been rapidly utilized in various business scenarios, including multi-domain FAQs for small and medium enterprises (SMEs) (Damani et al. 2020; Shalyminov et al. 2020), customer services in the banking industry (Yang et al. 2021b) or e-commerce platforms (Yang et al. 2021a; Li et al. 2021), and emotionally resonant conversation (Chang and Hsing 2021). Observing an increasing number of studies using transformer technology, we believe it will continue to dominate the NLP field for a while.

NLU refers to the challenging task of endowing a machine (computer) with the reading comprehension capability of human languages, including making a computer understand natural languages and confirming its realization. It is a common, necessary component in pipeline chatbot design to maintain human–computer conversations and recognize the primary semantic information based on pre-processed user input. Previous practices were closely related to pattern-matching techniques. An NLU module must acknowledge the possible sentence pattern in the user utterance and determine the most matched predefined one for the subsequent NLG. The matching process was usually string-level and widely used the distance comparison between two sentences (e.g., cosine similarity) as the matching similarity (Thomas 2016; Pilato et al. 2007; Wei et al. 2014; Setiaji and Wibowo 2016; Augello et al. 2009). Currently, the modularization design of the pipeline structure demands refining the extracted knowledge and capturing more information from natural languages. Deep learning technologies can produce extraordinary performance in such fine-grained mining of sentence semantic information. Unlike matching a similar sentence structure to give a preset response, the NLU module in the current pipeline structure will perform several subtasks to generate more granular semantic content, leading to more accurate answers.

NLG is the fundamental function of a chatbot that produces responses that interact with users. It is the last component in the dialogue systems of pipeline structure and the only essential constitution in end-to-end design. Response-producing methods can be categorized into two types from an acknowledged technical point of view: retrieval- and generation-based. When receiving user input, responses given in the retrieval-based methods are predefined, while those provided with the latter methods are generated word- for-word. Furthermore, based on our observations from the literature of the last five years, retrieval-based techniques can be refined further as scoring models and response action selection regarding the utilization of the preset responses. This difference in model input and output design affects developers’ preference for deep learning technologies in the response retrieval function. Accordingly, we summarize these three response-producing ways of NLG to conduct comprehensive comparative analysis in this section: (1) scoring model to rank response candidates, (2) classification model for response selection, and (3) response generation.

To enrich diversity and improve the relevance of responses, some researchers utilize external knowledge apart from the given contexts and utterances to assist in response production. A common practice based on deep learning is introducing extra memory space to build a neural network and training it to learn and store task-related knowledge. This additional knowledge needs to be provided artificially to train the neural networks. The models are required to derive more accurate and valuable content from user utterances and enhance the performance of downstream identification and generation components with the additional learned knowledge.

One trending approach is infusing user emotion recognition into the NLU process to optimize the response performance regarding anthropomorphism. Researchers considered empathetic conversation an interactive service of high quality in business situations (Chang and Hsing 2021). They believed that user emotions could reflect the performance of dialogue systems and thus have made various attempts to incorporate human emotion detection into conversational agents and improve their anthropomorphism. Majid and Santoso (2021) added a sentiment classification function in the NLU process to provide satisfactory services. Chang and Hsing (2021) integrated a CNN into Bi-LSTM for emotionally resonant response generation to recognize user emotions, which were further infused into the generating process. Detected emotions can be utilized as indicators for user desire measurement to design the reward in DRL technology, which could speed up the agent learning human emotional feedback. For example, Tiwari et al. (2021) and Zhang et al. (2021) designed immediate rewards based on the numerical representation of contextual sentiments detected by GRU or LSTM models to achieve an instant evaluation of response actions in transaction services.

In addition to the universal sentiment knowledge, some attempts at the utilization of specialized external knowledge have been made for specific commercial applications., Some researchers tried to incorporate a topic domain-related recognizer into the NLU component to improve the user service experience from the relevance of responses. In transaction services, Liao et al. (2018) leveraged an HRED model to provide tips on product styles satisfying customers’ fashion needs. Nangoy and Shabrina (2020) utilized a CNN model to classify the product type in user queries. For persona-specific conversations, Olabiyi et al. (2019) introduced and upgraded the HRED model integrated with GAN to learn the features of speaker personality, location, and sub-topic and disambiguate them before the process of generating responses.

Some additional knowledge can be brought in to increase the efficiency of automated conversation services. Ferrod et al. (2021) designed a bi-directional RNN-based model to match an appropriate expertise level with user demands in telco commerce. Lin et al. (2021b) added a text classifier to decide whether to wait for user input or give a response during the e-commerce conversation. Yang et al. (2021b) adopted an LSTM to predict user abandonment behaviors to switch to other modes of banking services timely.

The external knowledge can be represented in a high-dimensional form to facilitate pertinent conversations. Lin et al. (2021a) developed a GNN to jointly learn the customer and product embedding from a customer-product knowledge graph, which was expected to enhance the conversation connections between the customers and their target products in shopping guidance scenarios. The above attempts can effectively improve the performance of downstream tasks and optimize the self-service experience for users, which inspires us to enrich and intensify NLU functions by magnifying the multidimensional exploitation of available knowledge.

Chatbot’s built-in pipeline architecture presents an explicit information processing flow for user utterances. Its NLU component extracts the knowledge from pre-processed natural languages, while the NLG component receives the NLU extracts and produces the response considering dialogue contexts and states. Each component can be adjusted and improved independently based on the designers’ requirements, and the NLU component is a signature ingredient in this structure. Although the pipeline design requires more human manipulation and suffers the unavoidable error propagation issue among components, it is beneficial to distributed processing and validation of effectiveness for independent optimization of each component. In addition, the eventual pipeline design can be further differentiated due to the technical characteristics of different NLG technologies.

An end-to-end architecture means the design artifact can process original input data and produce final output without following the paradigm of step-by-step knowledge extraction. The development of deep learning technology enables these distributed operations to be integrated into a hierarchical model for collaborative learning of text features. From a supervised learning perspective, all constituent parts of an end-to-end model are trained jointly to learn the data features and update the model parameters. A dialogue system built in this structure can lessen cumbersome manual intervention in the knowledge construction process. It can be regarded as an ensemble model with NLG functionality. Generally, researchers would utilize sufficient corpora of a specific domain to train a deep learning model with a complex structure to capture the syntactic and semantic features of dialogues as fully as possible. Similarly, chatbots in end-to-end architecture can also be differentiated by the common retrieval- or generation-based methods, essentially the same as the techniques used in the NLG component of the pipeline-based design.

Chatbots should be deployed in more industries or businesses to automate customer services because user queries can be handled 24/7, thus increasing productivity and reducing the need for human labor and expenditure. Researchers or developers have designed and implemented chatbot functions adapted to specific domain requirements. However, most existing chatbots are built for e-commerce scenarios or technical support of products where the business value is not fully reflected. Applying chatbots to new areas may have unexpected effects. Even Eliza’s creators did not realize that chatbots could be used beyond psychology and that we are currently in a deep learning boom. This exploration requires us to observe the tedious or complex human tasks that can be automated or partially replaced in daily life, especially under the impact of COVID-19. Thus, broadening chatbot adoption into new areas, such as individualized customer care, live streaming, short video marketing, online collaboration, farmers’ market digitization, and so on, is well worth exploring.

We should also try to integrate more emerging technologies into chatbot design to examine the improvement and adaptiveness of the technique. Attempts to apply new technologies to chatbots are conducive to popularizing chatbot technology. A chatbot is an application closely related to the development of computer technology, while the chatbot technology involved in business research is often less cutting-edge. In addition to being unable to tap into the commercial value of burgeoning technologies in time, studies using relatively backward technologies have difficulties attracting the interest of researchers from other fields, which is not conducive to enhancing the influence of our discipline in this field. For example, as a branch of deep learning, the practical commercial value of the CapsNet technique has rarely been reported in the business chatbot literature, which is expected to achieve better performance than CNN.

Apart from the fascinating algorithms used for better response production and plentiful functionalities, chatbot performance also benefits considerably from ground-breaking physics and engineering technology similar to the computational applications of neural networks inspired by biology. Quantum technology application is a field where an exponential set of input information can be manipulated simultaneously (Chen and Zhang 2014) from a micro Quantum perspective. The Quantum computational system can deal with data with distinctively quantum properties of uncertainty and entanglement (Bennett and DiVincenzo 2000) and represent more data states with less space than conventional computation. A possible Quantum chatbot is expected to receive multiple contradictory inputs from the environment and still develop an excellent response given the conflicting inputs. For example, a Quantum chatbot can react accurately to complicated human expressions in a targeted manner if complex emotions in an utterance can be understood and captured effectively.

We believe that as computer technology matures and develops, chatbot behaviors will be closer to human beings. Chatbots are also expected to be the next significant technological leap in automatic conversational services (Suhaili et al. 2021). Consequently, we should keep pace with advanced technology associated with chatbots and try to adapt and compare them for business chatbot design.

The chatbot is an IT artifact that engages in frequent human–computer interaction, and user feedback is integral to the interaction. Considering and studying users’ behaviors or psychological activities is necessary when applying and designing chatbots. However, deep learning models are particularly perplexing because of their black-box nature (Gehrmann et al. 2020), confining human understanding and technology adoption (Gaur et al. 2021). Although this article conducts a thorough review and systematic analysis of applications and characteristics of mainstream deep learning technologies, how the adoption of different network techniques in chatbot design affects human–computer interactions remains unclear.

Inspired by a famous design science research framework proposed by Hevner et al. (2004), we address chatbot research by building and evaluating the artifact and testing whether the employed deep learning technologies meet the identified business needs. At this stage, where deep learning has been widely utilized in laboratory-level chatbot design, few studies have examined its human-oriented effects, limiting its extension to practical business scenarios that require high certainty and stability. An observation is that the banking industry prefers a pipeline-based chatbot framework that can explicitly demonstrate the information flow in chatbot systems with a predictable response produced. Therefore, apart from the feasibility of new technology, assessing the effects of adopting the technology on human experience and activities and examining its practical usability for improving chatbot design are also necessary. Although lacking in examinations of deep learning under chatbot contexts, some interesting studies can contribute to our better understanding. Luo et al. (2021) summarized several chatbot studies of usability analysis from the perspective of task performance, user attitudes, user trust, and user adoption, which could be extended to deep learning perception in chatbot design to unfold the mechanism of how it affects human beings.

A framework or guideline for designing a practical chatbot systematically and identifying its reasonable value may be necessary due to the different extents of mastery of various disciplines and technologies. The major challenge for chatbot development is its resource-intensive nature in terms of skills, time, and user interactions (Jackson and Latham 2022). With the rise of powerful technology, such as new deep learning and reinforcement learning methods, considering the technique features, business needs, and human factors in IT artifact design to improve performance comprehensively has become possible. As modern chatbots and their building technologies have become more diverse, more meta-theories or design principles are necessary to guide and regulate artifact construction.

Some researchers have been committed to generalizing practical frameworks or approaches to guide the chatbot design in some commercial applications. Lai et al. (2019) designed a security control procedure for banking chatbots and analyzed the e-commerce security strategies to reduce the security risk and concretely protect customer data security and personal privacy. Albert et al. (2019) affirmed the powerful impact of deep learning and considered its incorporation into a robust step-by-step development approach to business interaction systems. Sperli (2021) proposed a framework to model different cultural objects into a unified data model to support tourists’ self-services. Other researchers have shared far-sighted views following characteristics of different scenarios based on their observations of chatbot performance. Prabowo et al. (2018) compared the LSTM and simple RNN models in the context of customer service talks across business fields. They summarized their performances and offered suggestions from the perspective of the response accuracy and consumed time. Khan et al. (2019) conducted a correlative analysis of advanced AI technologies. They discussed the applications and inexpediencies of intelligent assistants to provide insight into adapting chatbots for specified scenarios.

Chatbot measurement methods are also necessarily upgraded to support advanced chatbot testing. Przegalinska et al. (2019) proposed a new approach to track and evaluate the interaction performance of deep learning-supported chatbots to help build better social bots fitting business or commercial environments. Huang et al. (2021) designed an assessment framework that can be used to identify the adoption susceptibility of chatbot applications in the hospitality and tourism industries.

The above studies provide a theoretical reference for the construction of business chatbots and guide individuals and enterprises to consider the aspects or indicators in evaluating the chatbot design. It is conducive to various disciplines learning from each other on the focus and improvement direction of appropriate and effective chatbot construction.