Generative Service Provisioning for IoT Devices Using Line Graph Structure

A service subgraph helps Internet-of-Things devices access resources in a dynamic Internet-of-Things device network. We propose a service subgraph generation method for Internet-of-Things device networks. Service subgraph generation aims to find more capable neighboring Internet-of-Things devices for service provisioning. We apply a line graph structure for an adequate representation of device resources. The line graph structure effectively represents the resources in the generated service subgraph. A general node classification problem constituting the generated service subgraph identifies the appropriate resource binding for service provisioning. A node in the service subgraph corresponds to a unique relationship between devices. Service provisioning is guaranteed by reinforcement learning based on the resource binding identified by node classification. The proposed line graph structure and resource binding significantly enhance the traditional intelligent resource allocation method. In addition, the proposed scheme can effectively attain service subgraphs with very low computational complexity. The proposed generative service provisioning generally has a significantly lower occupation probability than the swarm intelligence-based algorithm. The average value of the occupation probability is 0.49 with the proposed method. It is 0.12 lower than that of swarm intelligence-based algorithm.


I. INTRODUCTION
In the Internet of Things (IoT) environment, a large pool of devices cooperates. Sensors and actuators in an IoT environment activate several IoT-based services. For example, a smart building collects data from thousands of sensors, and actuators, such as air conditioners, respond accordingly to sustain an appropriate environment. Another example of an IoT-based service is self-driving cars, which use various sensor data sources to make driving decisions. Conventional IoT services must cooperate with other services. A resource can be forwarded to the neighboring devices to satisfy the service requirements of a service requester. Resources from multiple devices can be combined in a small area. The devices The associate editor coordinating the review of this manuscript and approving it for publication was Liang-Bi Chen .
in the IoT network can function as service requesters and resource providers simultaneously.
The network typically consists of many requesters and a relatively small number of providers. Service provisioning binds various primitive resources to meet the requirements of requesters [1], [2]. Service provisioning enhances resource utilization in various fields. In industry, predictions on services can be made to reserve resources [3]. The network slicing becomes gains efficiency by mapping resource status [4]. The quality of services (QoS) provided by primitive resources must be well coordinated in a single service provisioning to satisfy the service requests. A service requester typically has a list of desired services with different requirements. For each requester, service provisioning presents a pool of resource providers that can offer sufficient resources.
Requesters prefer providers that offer higher QoS. A graph is an appropriate representation of the provider pool [5]. Considering that all devices are connected in an IoT environment, the service-provisioning problem is equivalent to finding the best subgraph from an overall device network. A subgraph is a subset of the nodes and links selected from the original graph. Graph-based learning techniques are advantageous in complex applications. Recently, graph-based learning has focused on relational features between nodes or between links [5], [6], [7], [8]. Compared with the feature aggregation or concatenation of traditional graph-based learning, relational features increase data informativeness. Graph-based techniques have been applied to subgraph detection or subgraph generation.
In prior studies, the objective of subgraph detection or generation was to find a subgraph that could delegate the original graph. A frequently detected subgraph exhibits recurring or common features in the original graph. For example, a common connection between molecules can represent a specific chemical characteristic in the molecular structure. In IoT environments, subgraph detection is used to detect malware or botnets in an IoT network [8].
A provider pool for the service requester can be represented as a subgraph of the IoT network. A well-constructed service subgraph includes the most capable candidate providers for the requesters. Moreover, the subgraph enhances its usability by including the next candidate provider in the subgraph. The information required to construct a subgraph is the provider's resource status. A line-graph structure is useful for constructing a subgraph. A line graph converts node features into link features or vice versa. The link feature of the original graph contains the relational information (i.e., connectivity) of the two nodes. By applying a line graph, the node features in the line graph correspond to the relational information in the original graph. The line graph has the advantage of representing both the device's resources (i.e., CPU, storage, or sensors) and the relational information (i.e., connectivity between two devices). In [9], the link prediction problem was changed into a classification task by applying a line graph. The line graph generally has a smaller number of training parameters, which increases the learning efficiency and convergence speed of the problem.
Deep reinforcement learning (RL) implements a practical RL scheme for various problems. The cost-minimization problem with multistep decision-making is a typical deep RL problem. A recent study [10] used deep RL for network planning. Deep RL effectively prunes the search space to increase solution exploitation speed. A well-designed state representation is a critical factor for guaranteeing the performance of deep RL. Many previous studies have adopted a new state-representation framework [11], [12], [13]. In the literature, exploitation of the Markov decision process in graph representation outperformed matrix representation.
In this study, we proposed a generative service provisioning method, which uses deep RL and a line graph structure to address service provisioning in IoT networks. An IoT network comprises devices with different resources. These devices can be service requesters, resource providers, or both. Deep RL determines a specific subgraph from the original graph. We compared the proposed generative service provisioning with ant colony optimization (ACO), a swarm intelligence-based algorithm [14]. The ACO algorithm can identify a service subgraph. However, the proposed scheme exhibits faster convergence.
The remainder of this paper is organized as follows. The system model and problem formulation are presented in Sections II and III, respectively. Then, the proposed scheme is described in Section IV. In Section V, the results of the simulation and a discussion of the results are presented. Finally, the conclusions of this study are presented in Section VI.

II. SYSTEM MODEL
Consider an IoT network with N devices, M services, and Z resource types: the total set of devices D total = {d r }∪D where d r denotes a service requester and D is a set of N − 1 devices. A service subgraph is the feature graph of a requester. When we designate d r as d 1 and let D = {d 2 , d 3 , · · · , d N }, the proposed model aims to find a service subgraph of a requester device d 1 . The total set of services S total = {s 0 } ∪ S where S = {s 1 , s 2 , · · · , s M } and s 0 defines ''no service,'' which requires no resources. Each device can function as a requester, a provider, or both. We assume that Z fixed resource types exist in each IoT environment. A resource can be either a value-described resource (e.g., CPU, storage, RAM) or an existence-described resource (e.g., sensors and actuators).
A requester (d r ) requests service j with probability p rj . We assume that all the services in S total have an equal probability of occurrence. A requester has an individual list of preferred services (i.e., services can be classified as ''preferred'' or ''not-preferred'' by the requesters). Let a rj be 1 if the service j is the preferred service of the requester (d r ), and 0 otherwise. The probability α r , where the requester (d r ) requests any service, is as follows: where r = 1, 2, · · · , N and j = 0, 1, · · · , M . We divide by M + 1, which denotes the total number of M services and a ''no-service.'' At each time step t (i.e., iteration), the requester attempts to request a service. The system model assumes that a service forms a one-to-one or one-to-many relationship between a requesting device and a providing device. Similar to service preference in requesters, providers can ''offer'' or ''refuse'' services. The term ''offer'' refers to services that require fewer resources than the resources possessed by the devices.
Let b pj be 1 if service j is offered by the provider (d p ), and 0 if it is refused. Under this assumption, let β pj be the probability of service j being provided by the provider (d p ) in the IoT environment. The probability β pj is as follows: where p = 1, 2, · · · , N and j = 0, 1, · · · , M . To model device occupation in the IoT environment, we adopted a probability distribution to predict the ''unoccupied'' devices. The term ''unoccupied'' refers to a device that does not operate any service and can provide future requested service. Let a random variable X pj denote the service j offered by the provider (d p ). At each iteration, X pj follows a binomial distribution with probability β pj . As n → ∞, the binomial distribution approximates a Poisson distribution. Let the random variable Y p denote the occupation of the provider (d p ). Then, the random variable Y p = j X pj follows a Poisson distribution.
Note that a device node acts as either a requester or provider. Whenever a service request is generated in the network, we identify the service requester (d r ) and search for resource providers (d p ). The device node resets whenever a service request is generated. A resource provider for a previous service request can be a service requester and vice versa.

III. PROBLEM FORMULATION
All devices have different available resources, and services have different service requirements. This heterogeneity complicates the service subgraph generation. A service subgraph is a tree of devices rooted in a requester. To find the service subgraph (SG rj ) of a requester (d r ) for service j, we make the following assumptions on the service subgraph: • The requester itself is the first device that can provide service to the requester.
• A device can offer resources only once. The resources deplete after being offered. Hence, reexploring the device is meaningless. A well-designed service subgraph allows a service requester to be assigned resource providers who offer desired services. The quality of service (QoS) for service j provided to a requester (d r ) is defined as Q SG rj . This value is determined by the product of the unoccupied probabilities of all resource providers in the service subgraph SG rj for service j. The service subgraph SG rj refers to the set of resource providers that are used to provide service j to requester d r . The occupation of each provider (d p ) is represented by Y p , and the unoccupied probability of each provider is represented by (1 − Y p ). The product of the unoccupied probabilities of all providers in SG rj , p∈SG rj 1 − Y p , represents the overall unoccupied probability of the service subgraph for service j. This unoccupied probability is directly related to the resource availability in the service subgraph and is used as a measure of the QoS for service j provided to requester d r .
Note that, the average QoS achieved by the service subgraph for all services of requester (d r ) is calculated by equation (4).
where S r is the set of services preferred by the requester (d r ).
|S r | means the number of services in the set S r . We define all devices before the provider (d p ) as the predecessors of d p . Other devices located after d p are successors. A single provider can provide a service. However, we can assume a case in which no device can provide service alone. The service may require extremely high computational power or various types of sensor data. Service provisioning states that multiple devices cooperate in providing the requested service. The idea of service provisioning can help requesters provide services faster while satisfying QoS. With good service provision, a combination of low-performance devices can replace a single high-performance device. Highperformance devices are more likely to be occupied by other service requesters. The resource-binding scheme incorporates its predecessors' available resources and is useful in determining available resource providers. Resource-binding scheme emulates the transpiration process in plants. Plants transport water from the roots to the leaves, which is required for photosynthesis. The leaf and root are the requester and potential provider, respectively. Similar to transpiration, the available resources are combined from the requester (root) to the providers (leaves) in the service subgraph to offer the service (transpiration). Fig. 1 shows the service subgraph of a requester from the original graph and how to bind resources through the service subgraph. The resource provided to the device r for service j is the sum of the resources from unoccupied predecessors.
A SG rj represents the combined resource of all devices in the service subgraph SG rj . R p represents the resources owned by each provider (d p ) in SG rj , and (1 − Y p ) represents the resource availability of provider (d p ) (remember that Y p is the occupation probability of provider (d p ), and (1 − Y p ) is the unoccupied probability). The product of R p and (1 − Y p ) represents the current resource status of provider (d p ). The sum of (1 − Y p )R p for all providers in SG rj represents the combined resource of all devices in SG rj . In other words, it is the total resource available for use in SG rj . The service subgraph quality can be obtained by computing (3), where the providers of each accepted service j are the devices that maximize Q SG rj under a resource-binding scheme.
ACO-based algorithm shows effectiveness in resource allocation and task offloading problems. The basis for the ACO-based algorithm is that ants travel through different routes to accomplish certain objectives. The modification can be made by giving different constraints on traveling or pheromone update [15], [16].
The remaining problem is to determine a good service subgraph. The service subgraph connects the devices in an IoT environment. The heterogeneity of resources and devices increases the complexity of connections between devices. In the following section, we present the solution to finding a service subgraph with the idea of a line graph and deep reinforcement learning.

IV. GENERATIVE SERVICE PROVISIONING METHOD
The proposed generative service provisioning method focuses on generating a service subgraph. The service subgraph helps the requester find a set of adequate providers for all services. Service provisioning finds a group of devices that offers a service in a graphical the form of a service subgraph. Another essential part of the generative service provisioning is resource-binding, which allows the device to gather available resources in the service subgraph. The proposed scheme is an iterative process consisting of two steps: the first step involves generating a service subgraph, and the second step involves evaluating the generated service subgraph. Equation (4) represents an evaluation metric for the generated service subgraph. Table 1 is the pseudo code of the proposed method.
In the proposed service provisioning, pairing devices should inform the resource difference. We used a line graph of the original graph for service subgraph generation. Every pair of devices in the original graph creates two nodes, indicating resource differences. For example, device pairs A and B in Fig. 2(a) are converted to nodes AB and BA, respectively, in Fig. 2(b). The line graph converts the link selection problem in the original graph G to a node classification problem in the line graph L (G). If a node in the line graph is classified as ''active,'' then the corresponding two devices and the directed link between the devices are selected for the service subgraph.
The link prediction problem requires combining the features of individual nodes before generating a subgraph. A common approach for this on the original graph is to use message passing, which combines the features of neighboring nodes to create an edge feature. However, the proposed line graph structure simplifies this process by replacing message passing with a simple subtraction operation. This results in a significant reduction in computation time. In the original graph, updating node features through message passing requires O(n) computation for a single node (where n is the number of nodes in the network), and O(kn) computation for k iterative updates. When applied to all nodes in the original network, the computational complexity becomes O(kn 2 ). In contrast, the subtraction in the line graph only  complexity of O(n). The overall feature update complexity for the line graph is O (n) + O(km), which can be approximated as O (km) when m is larger than n. In the most complex cases, m is equal to n(n − 1), but in typical communication networks, m is significantly less than n(n − 1). Therefore, the line graph structure can greatly reduce the amount of computation required.
Service subgraph generation is a node-classification problem for identifying active nodes in L(G). The node features in L (G) are the inputs for node classification and represent the resource difference between the devices. Feature subtraction is a simple but effective way to show the difference. However, simple subtraction still requires serialization in the standard form. The range and unit of each resource type are different (i.e., value-described resource or existence-based resource). The following insights are advantageous to operate as a practical input in a neural network for node classification: • The providers in the service subgraph should have at least one better providable resource than the requester (i.e., higher-performance CPU or more storage).
• The diversity of resources must be more recommendable than the sufficiency of the resource.
Given these insights, we propose a representation method applied to generate the line graph L(G). The representation of device features in L (G) is a binary vector of size (1 × Z ). The component of the binary vector is 1 if the node has a better providable resources and 0 otherwise. The device with a zero vector can be neglected because it has no available resources. The proposed representation method reduces the number of devices in L (G). Additionally, the binary vector representation eliminates the need to standardize or form resources in advance of learning. The binary vector representation reduces the complexity of the problem.
One of the candidate methods for service subgraph generation is the naïve service subgraph generation. The method has a severe problem caused by the mutually connected devices. The mutually connected devices generate a cyclic service subgraph between them. Effective service provisioning is complex owing to the presence of cycles. Hence, we designed a modified service subgraph generation method that includes resource binding. Modified service subgraph generation was performed using deep RL. The neural network used to classify the active nodes in the line graph should be updated to generate an effective service subgraph. Deep RL is a technique that updates neural networks using a reward function. We used the average quality value of the generated service subgraphs defined in (5), as the reward. On average, deep RL updates the neural network to be effective for all service requesters. The service subgraph enables all service requesters to have a similar QoS.
Deep RL uses different service requests from all requesters to develop a single neural network. The rewards may use average quality value or utility-based rewards such as the providers' occupation. The occupations differ in each service subgraph. Some requesters may have a service subgraph with a high occupation but a low occupation for other requesters. The average QoS of all generated service subgraphs determines the overall performance and develops the neural network with general knowledge. The deep RL model uses the resources of each device as the input feature which is the state in deep RL. The action of the deep RL agents is to activate or deactivate the node, which is the connection between the devices. Then, the deep RL model evaluates the overall learning through the average QoS of the generated service subgraph (see the equation (3) to calculate QoS). The Deep RL descriptions are represented in Table 2.
The resources of these devices are not constant and can vary over time. In order to take this fluctuation into account, we apply the time variation to R p and Y p in equation (5). Specifically, we define R p (t) as the resource of the provider (d p ) at iteration t, where R p (t) represents the original resource owned by d p in the IoT system model. The formulation for R p (t) can be represented as follows: The product of the unoccupied probability, represented as (1 − Y p (t)), and the original owned resource (R p (0)) represents the current resource status at iteration t. The first step in this iteration involves classifying the nodes of the line graph generated from resource R p (t). In the second step, the resource is updated to R p (t + 1). At each iteration t, each device generates a service subgraph. It is worth noting that the service subgraph, SG rj , can be redefined as SG rj (t) to account for the iteration index t.
The neural network for each iteration classifies the active nodes of the service subgraphs presented in a line graph form. The reward is the average quality of all service subgraphs. The neural network is updated in response to the reward. Reinforcement learning using line-graph-based node classification generates an actual service subgraph from the original graph.
The objective of the proposed deep RL model is to use fewer parameters while maintaining a good performance. It is also important to find resource-binding to provide services in a distributed manner. We compared the proposed method with an ACO-based swarm intelligence-based algorithm in the same environment model. A swarm intelligence-based algorithm develops the collective behavior of life groups. Swarm intelligence has been applied to many domains and routing problems [14], [17], [18]. ACO (Ant Colony Optimization) is an effective Swarm Intelligence-based algorithm that uses the concept of ants using pheromones to guide the other ants. The ACO-based algorithm was used to address routing problems in wireless sensor networks [14]. In the literature, the trailing ant can obtain promising perspectives from the leading ant using pheromones. The pheromones indicate route quality. If trials with different levels of pheromones are left to determine routes to the prey, the pheromone-based solution addresses the presence of desired resources in the service subgraph. We modify the method in the literature [14] for comparison. In the proposed system model, the ant travels through the device until sufficient resources are accumulated. The pheromone level is the probability of selecting a device. We define the pheromone level ρ u of a link in u-th travel as follows (see Li et al. [18] equation (9)∼(10)): where γ is the pheromone fading rate, and γ = 0.9. The variable x is 1 if the device is chosen for travel u. For each travel u, the unoccupied devices are initialized following the probability defined in Section II. The ant selects an untraveled device with respect to ε-greedy algorithm. If the selected device is unoccupied, the ant accumulates resources from it. The ant repeatedly selects the next device until it accumulates enough resources to provide all the requested services. The pheromone level is updated according to the travel route of the ant. Note that in u-th travel, the ant uses the most recently updated pheromone map. The pheromone map is a service subgraph generated by the ACO algorithm. With sufficient travel, the tree of links with high pheromone levels can be regarded as a service subgraph. We assume that the service subgraph consists of links with an above-average pheromone level. Equation (3) denotes overall quality metric of generated subgraph. The overall quality metric consists of quality achievement of individual services (equation (4)). The constraint of service provisioning is the resource provided by devices. Equation (5) denotes the combined resource of devices in the generated subgraph. To calculate the resource provided in the subgraph, we must monitor the current status of available resource of devices. Equation (6) denotes the resource availability according to time flow. Additionally, equation (7) indicates the pheromone level in each iteration for the ACO-based service provisioning.

V. EXPERIMENTAL RESULTS
The system model depicts an IoT environment consisting of N devices, M services, and Z resources. Each service's parameters, N, M, and Z, for each service influence the model complexity. We present the simulation results to demonstrate the performance excellence of the proposed methods. We constructed an IoT environment using devices and services. The constructed IoT environment was randomly generated from pre-defined perspectives. We limited resource variations by assuming the possible range of each resource. Table 3 presents the resource types used for the proposed model and ACO-based model. We present six resource types in the designed IoT environment (individual resources belong to one resource type). The resources of each device were initialized based on the resource types. Then, the actual resource is selected with a pre-defined probability (for example, a 1.6 GHz CPU with 0.5, a 2.0 GHz CPU with 0.3, and a 2.4 GHz CPU with 0.2).
The resource difference between service providers was used as the input of the neural network. Quantification to form a binary representation improves the convergence speed. The value-described resource was quantified in several steps. It is practical to describe the actual resource of IoT devices. Existence-described resources are naturally represented in binary form.
The simulation testbed comprised 100 IoT devices. Each testbed constituted randomly generated resources as defined in Table 3. The service types are presented in Table 4. We generated 100 service requests using randomly selected service requesters. The learning iterations were limited to 200 iterations. At each iteration, the reinforcement learning uses 10 random samples for the generated service requests. Note that each device is initialized following the resource types in Table 3. Fig. 3 demonstrates the average size of the service subgraphs generated by the two methods. The size of the service subgraph generated by the ACO-based model fluctuated over a relatively long time (see Fig.3 (b)). The ant has less knowledge until it converges on the pheromone map. The ACO-based model is a random-walk model [19]. The proposed generative service provisioning succeeds in determining the required resources for every graph search. Fig. 3 (a) illustrates rapid convergence to the ideal size of the service subgraph. The service subgraph determination accelerates as the learning progresses. The learning speed is critical for achieving higher RL performance. The learning speed can be regulated to balance the subgraph finding time and size of the subgraph.
The service subgraph generation latency is the time spent to make the service subgraph. Shorter latency refers to the faster service provisioning. Fig. 4 depicts the variance of latency for each method. The average latency of the proposed method is 1.70 ms, while the ACO-based service provisioning requires 3.54ms to make the service subgraph. The latency pattern demonstrates stepwise increment. The proposed method needs about 2ms when the subgraph size  reaches more than 10 nodes while the ACO needs 4ms from 16 nodes. Fig. 5 shows the number of assigned services per resource provider in the service subgraph. The proposed generative service provisioning illustrates the focused device participation in service provisioning. Approximately 80% of resource providers support less than five service requests at the same time. In ACO-based service provisioning, 60% of service providers support 6∼10 service requests simultaneously. Generative service provisioning has an advantage in managing relatively simplified resource-binding. The resourcebinding from the small number of service providers induces a small number of service support of resource providers, which leads to simple resource finding for future service requests.
During the initial stages of learning, it is inevitable that the unoptimized search and activation of connections, performed by the deep RL algorithm, may result in longer paths to reach the appropriate resource providers. The QoS, which is the product of the unoccupied probabilities of all providers in the service subgraph, is maximized when the path to reach the providers is shorter. Even the addition of a single node to the path can cause a decrement in the QoS value. As the unoccupied probability of a node is less than one, the multiplication value of unoccupied probabilities for QoS calculation (i.e., p∈SG rj 1 − Y p in equation (3)) decreases. However, with proper training, the deep RL algorithm ensures the maximization of QoS values for each requester. Once the deep RL training reaches a converged stage, search paths are minimized then every service subgraph achieves its minimum size. The providers in the generated service subgraph are classified to occupied providers. The optimized service subgraphs for service requesters in the network ensures the smallest number of device participation to support service requests.
The availability of a service subgraph is related to the occupation level of the resource providers. If the occupation probability Y p is high for the providers in the service subgraph, the service subgraph is likely to fail to satisfy a service request. Fig. 6 shows the distribution of occupations (i.e., Y p ). Compared to ACO-based service provisioning, the proposed generative service provisioning has a lower load for each service provider. The average value of the occupation probability (Y p ) is 0.49 with the proposed method. It is 0.12 lower than that of ACO-based provisioning.
The proposed generative service provisioning method generally has a lower occupation probability compared to the ACO-based provisioning method. We have divided the resource providers into ten sets based on their ascending order of occupation probability, as shown in Figure 6. The lowest set, consisting of resource providers with the bottom 10% of occupation probability, has a 0.2 difference in occupation probability between the two service provisioning methods. Although the differences become smaller as we move up the provider sets, the differences in occupation probability are still observed for all provider sets. The provider sets with the top 10% of occupation probability show a difference of 0.078.
The proposed generative service provisioning uses line graph structure to ensure the low complexity for problem resolution. The proposed method effectively makes tree of service providers to inform the requester in finding appropriate provider for the requested services. The generated service subgraph consists of providers that are less likely to be occupied. The low occupation probability indicates the chance of having sufficient resource for the service.

VI. CONCLUDING REMARKS
We introduced a service subgraph generation process using a line-graph structure and deep RL. A service subgraph is a tree of devices for better service offerings. Line graphs reduce the complexity of the subgraph generation problem. The search space to determine the available providers decreases, and the feature representation becomes easier to learn. The proficiency of the service subgraph increases with deep RL. RL learns and changes the service subgraph to create additional unoccupied devices. A service subgraph is a group of devices organized in a tree-like form for service provisioning. A well-constructed service subgraph is effective in environments with low-performance devices. We apply resource binding to the generated service subgraph to combine the resources of the low-performance devices. The proposed service subgraph generation method was compared with the ACO-based method. The proposed method outperformed the ACO-based method in terms of the convergence speed and availability of the service subgraph. An important characteristic of an IoT environment is its scalability. The proposed generative service provisioning should be effective in environments with many devices. An additional characteristic to consider is heterogeneity. The term ''heterogeneity'' can be derived from many aspects. Diversity of services can result in heterogeneity. The RL design implies the qualification of the best service subgraph in a heterogeneous IoT network environment.
Additional work is suggested. First, we used a probabilistic model to design an IoT environment in the proposed experiment. However, real-world applications have anomalies, noise, and randomness. Using a more realistic model to capture the behaviors of real devices would make the proposed model more applicable. Second, the proposed model can be improved by implementing multi-agent RL. The proposed model predicts the service provision of other devices with probability. By implementing multi-agent RL, the model can learn the dynamics of co-existing devices in the environment, which can prevent encounters with the same provider.
JOOHYUN KIM received the B.S. degree in industrial engineering from Ajou University. His research interests include the IoT networking, intelligent network operation, and blockchain networks. He has developed reinforcement learning methodology and IoT network simulator.
JAE-HOON KIM (Member, IEEE) received the B.S., M.S., and Ph.D. degrees in management science from the Korea Advanced Institute of Science and Technology (KAIST), in 1996, 1998, and 2003, respectively. He has developed various network operation frameworks and simulation test-beds. Also, he has experience on the mobile service design and strategy. He worked as a System Architect in wireless systems with Samsung Electronics and a System Engineer with SK Telecom, South Korea. Currently, he is a Faculty Member of Industrial Engineering with Ajou University, South Korea. His research interests include the IoT networks, blockchain platforms, and ubiquitous networks. He is a member of the IEEE Communications Society and the IEEE Vehicular Technology Society.