KR20190094070A - Spatio-cohesive service discovery and dynamic service handover for distributed iot enviroments - Google Patents

Abstract

Disclosed are a spatio-cohesive service search and dynamic service handover method for a distributed IoT environment. The spatio-cohesive service search and handover method includes a step of searching for an IoT resource set for providing a service set, which is a series of functions required for a task given in a distributed IoT environment. The step of searching for the IoT resource set may search for the IoT resource set through a spatio-cohesive manner in consideration of a spatial distance between a user and a service and between a service and a service.

Description

SPATIO-COHESIVE SERVICE DISCOVERY AND DYNAMIC SERVICE HANDOVER FOR DISTRIBUTED IOT ENVIROMENTS}

The description below relates to a technique for efficiently and dynamically searching for the appropriate internet of things (IoT) services required to perform user tasks.

Recently, IoT technology has been widely spread to provide various services utilizing IoT resources in an urban environment.

As an example of IoT technology, Korean Patent Publication No. 10-1397471 (Registration Date May 14, 2014) discloses a technology for providing an open IoT service.

Although commercial IoT-based systems adopt cloud computing models to effectively manage IoT services, the scale of centralized cloud computing models is limited due to the rapid increase in the number of IoT resources.

The present invention provides a method and system for efficiently and dynamically searching for an appropriate IoT service required to perform a user task by utilizing IoT resources that centrally locate a service-to-service distance in a distributed IoT environment.

A method performed in a computer system, the method comprising: retrieving a set of IoT resources for providing a set of services that is a set of functions required for a given task in a distributed internet of thing environment, the IoT The step of retrieving the resource set may include retrieving the IoT resource set in a spatio-cohesive manner in consideration of the spatial distance between the user and the service and between the service and the service. Generating a service search plan based on the space-coherency requirement; And searching for a service required for the task based on the service search plan, searching for a service that satisfies the space-aggregation requirement of the task, and then searching for the service and other services maintaining space-aggregation. It provides a method comprising the steps.

According to one aspect, generating the service search plan may include extracting a space-aggregation requirement specific to the task from a predefined task template.

According to another aspect, the space-cohesiveness requirement is expressed based on an ontology model and can be extracted using a rule-based reasoning method.

According to another aspect, the generating of the service search plan may include: using the search strategy of guiding traversal after expressing the space-coherency requirement as a graph abstracting the spatial location and the relationship of the service. And instantiating the service search plan to the graph.

According to another aspect, the search strategy is a spanning tree algorithm for configuring a path for searching for a child service from a parent service and assigns priority to each service according to the importance of the service. It can be configured as a service priority function to.

According to another aspect, the step of retrieving the set of IoT resources, IoT resources required to realize a service related to the task by propagating a service search request from a higher service to a lower service according to the service search plan instantiated in the graph It may include the step of searching.

According to another aspect, the searching for the IoT resource may include: searching for a candidate IoT resource capable of providing the lower service with respect to the upper service and selecting an IoT resource having the closest spatial distance among the candidate IoT resources It may include.

According to another aspect, retrieving the set of IoT resources may include handing over at least some of the retrieved services by monitoring the space-aggregation status of the retrieved services.

According to another aspect, the transitioning step includes a target function that periodically checks whether an IoT resource selected for the task meets the space-coherency requirement to minimize the number of IoT resources to be handed over for a period of time. Accordingly, an IoT resource that does not meet the space-aggregation requirement may be converted to another IoT resource.

According to another aspect, the step of retrieving the set of IoT resources, the step of selecting a service required for the task based on a policy learned through machine learning for the service available by the dynamic change of the IoT environment It may include.

According to another aspect, the policy maximizes the space-aggregation defined as a measure of how close the space distance between the user and the service is, while the handover count defined by the difference between the newly selected service set and the existing service set is used. Can be learned in the direction of minimization.

According to another aspect, the policy may be implemented as a neural network with a state vector representing coordinates and speeds of a user, a state vector representing coordinates and speeds of a service, and a relationship vector representing relative positions and speeds between a user and a service. have.

A method performed in a computer system, the method comprising: retrieving a set of IoT resources for providing a set of services, which is a set of functions required for a given task in a distributed IoT environment, wherein retrieving the set of IoT resources, Extracting space-aggregation requirements related to spatial distances between users and services and between services and services; Generating a service search plan by expressing the space-coherency requirement as a graph abstracting the spatial location and relationship of a service and then instantiating it in the graph using a search strategy guiding traversal; And searching for an IoT resource necessary to realize a service related to the task by propagating a service search request from a higher service to a lower service according to the service search plan.

A computer system, comprising: at least one processor configured to execute a computer readable instruction, the at least one processor for providing a set of services that is a set of functions required for a given task in a distributed IoT environment. The process of searching for an IoT resource set and the process of searching for an IoT resource set include searching the IoT resource set through a space-aggregation method considering a spatial distance between a user and a service and a service and a service. Generating a service discovery plan based on space-cohesion requirements including rules relating to spatial distances; And searching for a service required for the task based on the service search plan, searching for a service that satisfies the space-aggregation requirement of the task, and then searching for the service and other services maintaining space-aggregation. Provides a computer system comprising the process.

According to embodiments of the present invention, in order to receive a service required by a user in a distributed IoT environment, it is possible to search for a service available by being engaged with an IoT device, and the user may physically provide a service to the user while on the go. You can transfer services in use to IoT devices within range.

1 illustrates an example of a distributed IoT environment using a mobile ad-hoc network (MANET).
2 is a block diagram for explaining an example of an internal configuration of a computer system according to an embodiment of the present invention.
3 is a flowchart illustrating an example of a space-aggregation service search and transfer method that may be performed by a computer system according to an embodiment of the present invention.
4 illustrates a table summarizing official notation according to an embodiment of the present invention.
FIG. 5 shows an example of an ontology model representing space-cohesiveness requirements in one embodiment of the invention.
FIG. 6 illustrates an example of a rule expressed in Semantic Web Rule Language (SWRL) according to an embodiment of the present invention.
7 illustrates an example of a process of generating a service search plan according to an embodiment of the present invention.
8 illustrates an algorithm illustrating a space-aggregation service search process according to an embodiment of the present invention.
9 illustrates an algorithm illustrating a candidate IoT resource search process according to an embodiment of the present invention.
10 illustrates an algorithm illustrating a dynamic service transition process according to an embodiment of the present invention.
11 illustrates a machine learning based service search agent according to another embodiment of the present invention.

Hereinafter, exemplary embodiments of the present invention will be described in detail with reference to the accompanying drawings.

Recently, as the number of IoT resources increases rapidly, a distributed computing model based on mobile ad-hoc network (MANET) has been applied.

1 illustrates an example of a distributed IoT environment using MANET.

Referring to FIG. 1, in a distributed IoT environment, IoT resources may be directly accessed through a MANET. MANET enables IoT resources to interact with each other without the need to deploy infrastructure, providing users with services in a more efficient and flexible manner. In addition, complex services can be implemented by integrating other types of services, such as web services and cloud services, into the IoT to perform user tasks.

Task-based service provision framework is being developed to provide user-centered IoT service. In this framework, work is a description of the user's needs and involves the services required to provide the necessary functions. A service is defined as a set of functions required to support activities for user operations. Services are realized through service instances that require a set of resources, which correspond to IoT devices that provide specific primitive functionality.

In the present invention, it is assumed that an IoT resource has sufficient computing power and networking capability to configure a MANET without an infrastructure, and is used by a service gateway to join a resource to the MANET when the IoT resource is restricted by limited computing or networking ability. It is also possible.

This distributed IoT environment presents a new challenge of efficiently and dynamically discovering the right IoT resources. In other words, the new problem is to provide the IoT services needed to perform user tasks near the user. To address this issue, a number of studies are being conducted in service-oriented architectures and Web services domains. In particular, mobility, location dependence, and combinatorial possibilities of distributed services are considered as important issues for enabling effective service provision in a practical IoT environment. First, the availability of IoT services changes frequently due to the mobility of users and IoT resources. Thus, the search algorithm needs to dynamically search for valid IoT services that are essential for performing user tasks. Second, unlike traditional web services, the spatial location of users and IoT resources affects the effect of providing IoT services to users. In order to hand over the output of the IoT service to the user in an effective and efficient manner, the IoT resource must be located near the user. Third, since various services in the IoT environment must be coordinated with each other to perform complex user tasks, collaborative IoT resources should be consistently located in the space where users exist.

In the present invention, a spatio-cohesive service is defined as a service that enables the result of service coordination to be effectively transferred to a user by utilizing an IoT resource that intensively locates a distance between services around a user. Spatio-cohesivenss of IoT services are an important factor in maximizing the quality of experience (QoE) of user work. If a drop in space-aggregation of an IoT service is detected, some services must be replaced in MANET to ensure some level of space-aggregation required for user operations.

Accordingly, the present invention proposes a space-aggregated service search and transfer method for an ad-hoc IoT environment in which space-aggregation of IoT services is essential for performing user tasks with high QoE.

The space-aggregation service search and transfer method according to the present invention consists of two steps. In the first phase, a service discovery plan is created, which is a systematic plan for searching for services that can be coordinated together to perform user tasks. At this stage, various service search strategies, such as the spanning tree algorithm and service priority functions, are considered to produce the most effective search plan.

In the second phase, the space-aggregated service is retrieved and handed over using the service discovery plan created in the first phase. The space-aggregated service retrieval algorithm first finds a set of core services that meet the space-aggregation requirements of the task for the user, and then gradually searches for other services while maintaining space-aggregation with the services already found. In addition, the dynamic service handover algorithm monitors the space-aggregation status of the service and performs handover when some of the services cross the requirements boundary.

Hereinafter, specific embodiments for searching for and handing over space-aggregated services in a distributed IoT environment will be described.

2 is a block diagram for explaining an example of an internal configuration of a computer system according to an embodiment of the present invention.

An IoT service system according to embodiments of the present invention may be implemented through the computer system 200 of FIG. 2. As shown in FIG. 2, computer system 200 is a processor 210, memory 220, persistent storage 230, bus 240 as components for executing a space-aggregated service discovery and transfer method. It may include an input / output interface 250 and a network interface 260.

The processor 210 may comprise or be part of any device capable of processing a sequence of instructions. Processor 210 may include, for example, a processor within a computer processor, mobile device or other electronic device and / or a digital processor. The processor 210 may be included, for example, in a server computing device, server computer, series of server computers, server farms, cloud computers, content platforms, mobile computing devices, smartphones, tablets, set top boxes, and the like. The processor 210 may be connected to the memory 220 through the bus 240.

Memory 220 may include volatile memory, permanent, virtual, or other memory for storing information used by or output by computer system 200. For example, the memory 220 may include random access memory (RAM) and / or dynamic RAM (DRAM). Memory 220 may be used to store any information, such as status information of computer system 200. Memory 220 may also be used to store instructions of computer system 200, including, for example, instructions for controlling an IoT service. Computer system 200 may include one or more processors 210 as needed or where appropriate.

Bus 240 may include a communications infrastructure that enables interaction between various components of computer system 200. Bus 240 may carry data between components of computer system 200, for example, between processor 210 and memory 220. Bus 240 may include wireless and / or wired communication media between components of computer system 200 and may include parallel, serial, or other topology arrangements.

Persistent storage 230 may store components such as memory or other persistent storage as used by computer system 200 to store data for some extended period of time (eg, relative to memory 220). It may include. Persistent storage 230 may include a nonvolatile main memory as used by processor 210 in computer system 200. For example, persistent storage 230 may include flash memory, hard disk, optical disk, or other computer readable media.

The input / output interface 250 may include interfaces for a keyboard, mouse, microphone, camera, display, or other input or output device. Configuration commands and / or inputs related to the IoT service may be received via the input / output interface 250.

Network interface 260 may include one or more interfaces to networks such as a local area network or the Internet. Network interface 260 may include interfaces for wired or wireless connections. Configuration commands may be received via network interface 260. In addition, information related to the IoT service may be received or transmitted through the network interface 260.

In addition, in other embodiments, computer system 200 may include more components than the components of FIG. 2. However, it is not necessary to clearly show most of the prior art components. For example, the computer system 200 may be implemented to include at least some of the input / output devices connected to the input / output interface 250 described above, or may include a transceiver, a global positioning system (GPS) module, a camera, various sensors, It may further include other components such as a database. As a more specific example, when the computer system 200 is implemented in the form of a mobile device such as a smartphone, a camera, an acceleration sensor or a gyro sensor, a camera, various physical buttons, and a touch panel which are generally included in the mobile device are used. Various components such as a button, an input / output port, a vibrator for vibration, and the like may be implemented to be further included in the computer system 200.

Service discovery in a service computing environment may be classified into proactive service discovery and passive service discovery. Passive service discovery algorithms search services according to user requests. In a distributed IoT environment, due to scalability, services must be searched in a passive manner according to the requirements of user tasks. In addition, since the service search in the IoT environment requires the IoT resources required to provide a service, the service search in the present invention is closely related to the search for necessary IoT resources. In particular, the service discovery process in the IoT environment includes the selection of the best IoT resources among candidate resources that can provide the necessary services.

3 is a flowchart illustrating an example of a space-aggregation service search and transfer method that may be performed by a computer system according to an embodiment of the present invention.

The processor 210 may perform steps S310 to S320 included in the space-aggregation service search and transfer method of FIG. 3. For example, the processor 210 may be implemented to execute instructions according to code of an operating system included in the memory 220 and at least one program code described above. Here, the at least one program code may correspond to a code of a program implemented to process the space-aggregated service search and handover method.

3 shows the main steps and overall process of the space-aggregated service discovery and dynamic service handover algorithm. In the first step (S310), the space-cohesiveness requirements are extracted (S311) and a plan for service discovery and transfer is generated based on the space-cohesiveness requirements (S312 ~ S313). Space-coherency requirements depend on the location between two services, or between a user and a service, which must be located closely together. After the extraction is complete, the requirements are represented in the graph, and the service search plan is instantiated in the graph using various search strategies that guide traversal in the graph. In a second step (S320), the IoT service for the user's work in the IoT environment is searched in a space-aggregated manner based on the service search plan generated in the step (S310) (S321). In the second step (S320), the dynamic service transition step (S322) is periodically activated to monitor changes in the space-coherence requirement of the service, and dynamically transfers some service instances that are not spatially aggregated to other services to other service instances. Hand over.

The space-aggregated service discovery and dynamic service transition problem is formally defined as

The problem of space-aggregated service discovery and dynamic service handover is finding the IoT resource set D needed to provide the service set S _T needed for a given task T. Each service s∈S _T owns a service description des _S that contains information about the required functionality and constraints. The time series TS, which is a sequence of time instances τ _i , represents the topology change of the MANET. Time instance τ ₀ represents the time at which the job starts running. The MANET at time τ is represented by graph N (τ) = (D∪ {u}, E (τ)). The vertices of the graph include the IoT resource set D providing the service function and the user u consuming the service. Each vertex v has a function v.coord (τ) that returns the physical coordinates of the node at time τ. The service that can be provided using the IoT resource d_D is represented by d _service . The edge set of the network at time τ is defined as E (τ), where E (τ) is a set of direct links forming a MANET among IoT resources and users. The elements of E (τ) change as mobility changes the connection between the IoT resource and the user.

Assume that there is only one user consuming a service in the IoT environment. The present invention focuses on service retrieval for user tasks in a spatially cohesive manner.

The space-coherence requirement is defined as (m, n, l), where m and n are services or users (ie m, n∈S _T ∪ {u}), and are spatially close to each other within the upper bound l. Should be. R _T is a set of space-aggregation requirements for task T that can be automatically extracted from the service description of the task template. In addition, the space-cohesiveness requirements can be extracted from user preferences or manually provided by the user.

The above notation is summarized in FIG. 3.

In the present invention, the space-aggregation solution c _SC (τ) ∈C (τ) is found. Here, C (τ) ⊆2 ^D is a set of candidate IoT resources that provide a service of the task at time τ. The spatial distance between the resources providing services in each service pair (services m and n), or between the resources providing service m and the user n in set c, is defined by the function distance _c (m, n), where each space in the job -Should be minimized for cohesiveness requirements. In addition, the achievement of the requirement is the ratio of the distance to the limit value, which is zero if the distance exceeds the limit. Therefore, the achievement of the space-cohesion requirement r _i (c) with the candidate IoT resource set c can be measured as in Equation 1.

[Equation 1]

Furthermore, according to the definition of network connectivity (Brandes, U., Erlebach, T .: Network Analysis: Methodological Foundations.LNCS, vol. 3418. Springer, Heidelberg (2005)), the spatial-aggregation of the set of IoT resource candidates It can be measured as the minimum distance average of services that cause space-aggregation requirements. Therefore, the space-coherence objective function R _T (c) of the candidate resource set c may be defined as in Equation 2.

[Equation 2]

The space-cohesion of the candidate IoT resource set is a value between 0 and 1. Low values indicate that the IoT resource requirements are often not met. High values, on the other hand, indicate that most of the space-coherency requirements have been largely achieved by the resource.

The space-aggregation service discovery problem is to find a set of resources that provide space-aggregation services at the initial time c _SC (τ ₀ ), and the dynamic service transition problem is to IoT MANET, i.e., c _SC (τ _i ) (i> 0). When there is a change, we are looking for a new set of resources to provide space-aggregation services. The dynamic service handover problem also has an additional objective function handover (c (τ _i-1 ), c (τ _i )), which is the number of handovers from c (τ _{i -1} ) to c (τ _i ). To identify them. The objective function for service transfer may be defined as shown in Equation 3.

[Equation 3]

By minimizing the number of IoT resources to be transferred, it is possible to reduce the overhead of service transfer due to changes in IoT MANET. Therefore, we define the problem of finding space-aggregated services for user tasks while minimizing the cost of service transfer during the cycle of user tasks (Equation 4).

[Equation 4]

This problem is a limited multi-objective optimization problem because there are several objective functions for each space-coherency requirement with some constraints. Consider the IoT resource d _i selected for task T to see if the objective functions contained in R _T (c) collide with each other. The search algorithm searches for IoT resources necessary to provide spatially cohesive services to the services of d _i . Assuming that all resources and users are randomly and evenly distributed in MANET, the resources are expected to be distributed in all directions at d _i . Therefore, instead of d _i by selecting the alternate source d _'i At the same time increasing the space to achieve other requirements - one of the requirements to achieve cohesiveness required is reduced.

Search Plan Generation Steps (S310)

The process of extracting the space-coherency requirement (S311) is as follows.

Studies that semantically express functionality and QoS of web services (Chen, X., et al .: Web service recommendation via exploiting location and QoS information.IEEE Trans.Parallel Distrib. Syst. 25 (7), 1913-1924 (2014), Ma, Q., et al .: Semantic QoS-aware discovery framework for web services.In: IEEE International Conference on Web Services, ICWS 2008 (2008)) is based on semantic description of services. It shows that it is possible to infer the QoS requirements of the service in a way. Similarly, the space-aggregation requirements of user tasks can be extracted automatically from task templates. Thus, as represented in FIG. 5, a simple ontology model is defined that represents the space-aggregation requirements of the user's work. Ontology models are developed using OWL (Web Ontology Language) and are represented by UML (Unified Modeling Language) class diagrams. As represented in FIG. 5, a task has its own task template, which consists of multiple services. The service may have some service characteristics that indicate quality attributes and constraints of the service. In addition, services may be classified into one or more service categories. The services and users of the task can be aggregated to form service boundaries, which allows for the specification of space-aggregation requirements for the task. Finally, the set of space-aggregation requirements is extracted from the work template.

Spatial-aggregation requirements expressed based on ontology models can be extracted using rule-based reasoning. 6 shows an example of a rule expressed in SWRL (Semantic Web Rule Language). For example, the SWRL rule specifies that if a task requires an audio service with a volume attribute of less than 30 dB, the distance between the user and the audio service should be less than 5 m.

A process (S312) of generating a space-coherency requirement graph is as follows.

In the method proposed in the present invention, a space-cohesiveness requirement graph (SCRG) is used to express the space-cohesiveness requirement, in which the user and the service are the vertices (S _T ∪ {u}). The space-cohesion requirements between them are expressed as edges (R _T ). Define the vertex representing the user as the root of the SCRG. The label on each edge represents the upper limit of the space-cohesion requirement. The requirements graph is an abstraction of the spatial location and relationships of a service. This graph does not represent functional dependencies between services. In the present invention, it is assumed that the user of the SCRG and all services are connected.

The process of generating a search plan (S313) is as follows.

Based on the SCRG generated in the previous step (S312) to establish a service search plan that can systematically search for services. The service retrieval plan for job T is defined as in Equation 1.

[Definition 1]

In Equation 1, child _P is a subset of the space-coherency requirement and represents the path of the requirements graph to retrieve the set of child services from the parent service. nonchild _P is a complementary set of child _P. Thus, the IoT resources selected for service S are evaluated according to whether they meet the space-aggregation requirements of nonchild _P. Then, according to child _P , the subservices of service S are searched near the selected resources of S. 7 shows an example of generating a service search plan in SCRG.

Generation of the child _P set is performed by constructing a spanning tree of the SCRG. Therefore, the service search strategy in the present invention is composed of a spanning tree algorithm and a service priority function. The spanning tree algorithm is for constructing child _P , and the service priority function is for assigning priority to each service according to importance. This allows the algorithm to efficiently search for high priority services among the service's subservices. Various spanning tree algorithms may be used, such as Depth-First Search (DFS), Breadth-First Search (BFS), and Minimum Spanning Tree (MST). For service priority functions, algorithms can be used to calculate the centrality of services in the requirements graph. This is a well known indicator of the importance of the vertices in the graph, or the requirement boundary for the parent service at the service node for strict prioritization.

Space-aggregation service search and transfer (S320)

The space-aggregation service search process (S321) is as follows.

The space-aggregated service search algorithm finds the IoT resources required to realize the user work service from the subservices of the user node based on the service search plan established in the previous step (S313). The retrieved service then recursively seeks resources for the subservice. For each resource, a service discovery agent is deployed that can search for subservices near the resource, such as user requests. The service retrieval agent allows a user to request the resources of the retrieved service to retrieve the lower service near the higher service. Therefore, the service search request is propagated from the higher service to the lower service according to the search plan.

During the service discovery process, no resources may be available for subservices that meet space-aggregation requirements for the service. In this case, the resources of the parent service are recursively searched again until the service search of the parent service for the child service is successfully performed.

In the space-aggregated service search algorithm, there are two options for searching a service simultaneously and finding multiple candidate resources for the service. These options allow for an efficient tradeoff between failure rates and service discovery latency, depending on environmental conditions such as dynamic levels and density of deployed services.

8 shows Algorithm 1 for space-aggregated service search.

Algorithm 1 shows a space-aggregated service search algorithm executed recursively for each service retrieved. Service discovery is initially initiated by the user and propagated to IoT resources. The input to Algorithm 1 is task T, which contains its template and service set S _T to be retrieved for the task. The service retrieval plan created for the job is extracted from the job template, and a non-child service of the service is found to check for space-aggregation requirements based on the plan (lines 2-3). If a non-child service has already been discovered and does not meet the requirements, the resource attempts to retrieve its own service from the parent service (lines 4-9). During service rescan, the current resource of the service is deactivated and a replacement resource is retrieved for simplicity (lines 29-34). This method makes the failure resource invisible to subsequent processes. If all space-aggregation requirements of the non-sub-services are met, the service discovery agent of the resource initiates the sub-service discovery of the relevant service (lines 10-16). The search of the lower service is accomplished by finding a set of candidate resources that can realize the lower service near the upper service (line 20). After the set of candidate resources is retrieved, the resource selects the closest resource that can provide the subservice and starts the search process on the selected resource (lines 23-26). If no candidate resource is available for the child service, the resource re-searches the parent service (lines 21-22). Also, if the option cannot simultaneously search for subservices, wait until the previous search session ends before proceeding to the next search (lines 13-15).

9 shows Algorithm 2 for finding candidate resources.

Algorithm 2 finds the candidate IoT resource set by the service discovery agent of the resource. The resource requests the subservice (line 3) and finds a candidate based on the response of the other resource (line 4-10). If the answered resource can provide the required subservices and meets the space-aggregation requirement, the service discovery agent adds the resource to the candidate set (lines 4-7). If this option cannot find multiple candidate resources, it returns the candidate resources found first (lines 8-10).

Dynamic service transfer process (S322) is as follows.

Service handover needs to consider a set of services for performing user tasks, while traditional handover only considers a single access point, which is a major difference between traditional handover and service handover in IoT environments. In addition, it is necessary to consider not only the case of handing over between a user's mobile device and the resource but also the case of handing off between resources. In the present invention, a service is performed in a dynamic manner by using a service discovery plan generated for a user task.

10 shows Algorithm 3 for dynamic service handover.

Algorithm 3 has a structure similar to algorithm 1. Service transition is initiated by the user periodically checking whether a resource selected for a task meets the space-aggregation requirements and propagates to a service similar to the service retrieval algorithm. When the handover process is initiated in a service by the parent service, the associated service discovery agent on the resource discovers the candidate resource set for the child service using a handover decision rule with hysteresis margin and threshold (line 27-34). ). The transition decision rule calculates the space-cohesion between the parent service and the candidate resource, and the space-aggregation between the resource of the parent service and the current resource according to the space-cohesion requirement of the parent service and the child service. Unlike the service search algorithm, the bin candidate set indicates that there is no better resource available for the lower service in the vicinity of the higher service.

When a large number of IoT devices are distributed in urban-scale public IoT environments, in order to provide services required by a user, a process of searching for available services by interlocking with IoT devices is required. According to the present invention, physical effects such as actuators such as an actuator such as a display or an audio, etc., must be located close to a space in order to be provided to the user, and secured scalability by sequentially searching from IoT devices close to the user. In addition, the present invention provides a service discovery algorithm that allows multiple IoT devices searched by a user to be located nearby and communicate with each other efficiently. In addition, in order for a service being used by a user to be continuously performed while moving, there is a need to transfer the service to an IoT device within a range capable of physically providing a service to the user. Accordingly, the present invention extends the transfer technology existing in the general network environment to the IoT service perspective to provide a transfer algorithm that can continuously perform the IoT service even after the user searches for the service.

Therefore, in order to efficiently perform service-to-service interactions and effectively hand over the service coordination results to users, IoT services can be searched in the user's surroundings in a spatially cohesive manner, and the QoE level of user operations can be guaranteed. In order to dynamically switch from one IoT resource to another IoT resource, a service transfer method can provide a service in a stable manner when performance degradation against spatial aggregation is monitored.

In the embodiment of the present invention, selecting the lower service from the higher service is a method of selecting the IoT resource having the closest spatial distance among the found candidate IoT resources. In this case, since only the current space-aggregation state of the IoT environment is considered, efficient resource selection may be limited.

In another embodiment of the present invention, the best IoT resources can be selected through machine learning that predicts the current state as well as the future state.

11 illustrates a machine learning based service search agent.

The service discovery agent operates on the user's mobile device and searches for available IoT resources, that is, service providers, in the surrounding area around the user. It is assumed that the discovered IoT resources are classified for each service type and there is a fixed number of service types.

For each service type that the user needs, the agent applies the learned policy through machine learning to perform service selection. Policies are implemented and expressed in neural networks. Through this policy, the combination of choices made for each service type is defined as the action currently performed by the agent. After performing these actions within the IoT environment, the agent is evaluated for actions in the form of rewards and learns the policy to maximize the rewards. In the present invention, compensation may be defined through space-aggregation and handover times of selected services.

To apply machine learning, we define the space-aggregated service discovery problem in the form of POMDP (partial-observable Markov decision process).

POMDP is an extension of the Markov decision process (MDP), and the observation of the IoT environment is partially made. POMDP is defined by five elements:

(1) A state is defined as a set of states that an IoT environment can have.

(2) Action is defined as the set of actions that an agent can take in the IoT environment, and the IoT environment is affected by the action and moves from its current state to another.

(3) Observation is defined as a function that gives the agent a partial observation of the current state of the IoT environment.

(4) A transition function is defined as a function that represents the probability that an agent will transition to another state when it takes an action from one state.

(5) Reward is defined as a function that indicates a reward value that reinforces or discourages a behavior when a state transition occurs by an agent's action.

POMDP  Justice

The IoT environment is defined as a two-dimensional planar space in which a large number of IoT resources are evenly arranged as service providers, and there is one user agent who wants to perform work using services in the IoT environment. In this problem definition, IoT resources and user agents deployed in the IoT environment are defined as objects. In addition, it is assumed that all objects have their coordinates and velocity as properties and can be known. In addition, to define the state of the IoT environment, the states of the objects are defined and defined by coordinates, speeds, and service types. The set of states of the objects defined in this way becomes the state of the current environment.

In the space-aggregated service discovery problem, the user agent has partial observability based on Euclidean distance in the space between objects, so that the user agent can search for and use services located in close proximity within the IoT environment. have.

The agent's behavior is defined as selecting one service provider of candidate services for each service type. The number of candidate services available, ie the number of possible behaviors, is constantly changing due to dynamic changes in the IoT environment, and thus the policy-gradient is known in the present invention to flexibly cope with such a situation in the machine learning method. You can choose to use.

In the present invention, two compensation measures, space-cohesion and handover times are defined. First, space-cohesion is a measure of how closely a user and selected services are located in the space, and the handover frequency is defined as the difference between a newly selected service set and an existing service set by an action. By subtracting the number of handovers from the space-aggregation to make the final compensation value as one, we learn to maximize the space-coagulation while minimizing the number of handovers.

Service discovery agent

The service search agent maintains a stochastic policy for each service type that the user needs, which indicates the probability that a service provider searched for each candidate will be selected. By multiplying the probability function for each type of service, we get a joint probability distribution, which is the joint policy that the agent has for the whole service. This process assumes that the choices made for each service type are independent.

A policy may be expressed as a parameter in the form of a feed-forward neural network (FFNN), which is one of the methods suitable for expressing probabilistic policies. For each candidate service retrieved, the agent uses the state vector of the candidate service, the state vector of the user, and the relationship vector between the two as inputs to the policy. At this time, the relationship vector is obtained by subtracting the state vector of the user and the candidate service, which serves to indicate the relative position and speed of the user and the candidate service. When the output value of the candidate service is obtained by the policy expressed by the neural network, the softmax function is taken and then used as a probability value to select each candidate service.

In order to train the service search agent, machine learning models of known algorithms may be utilized. For example, the service search agent may be trained using an actor-critic algorithm.

Accordingly, embodiments of the present invention may select a service considering the current state and the future state according to a policy learned about the IoT environment through machine learning in the process of searching for a service required for a given task in the IoT environment. .

The apparatus described above may be implemented as a hardware component, a software component, and / or a combination of hardware components and software components. For example, the devices and components described in the embodiments may include a processor, a controller, an arithmetic logic unit (ALU), a digital signal processor, a microcomputer, a field programmable gate array (FPGA), a programmable PLU (programmable). It can be implemented using one or more general purpose or special purpose computers, such as logic units, microprocessors, or any other device capable of executing and responding to instructions. The processing device may execute an operating system (OS) and one or more software applications running on the operating system. The processing device may also access, store, manipulate, process, and generate data in response to the execution of the software. For convenience of explanation, one processing device may be described as being used, but one of ordinary skill in the art will appreciate that the processing device includes a plurality of processing elements and / or a plurality of types of processing elements. It can be seen that it may include. For example, the processing device may include a plurality of processors or one processor and one controller. In addition, other processing configurations are possible, such as parallel processors.

The software may include a computer program, code, instructions, or a combination of one or more of the above, and configure the processing device to operate as desired, or process it independently or collectively. You can command the device. The software and / or data may be embodied in any type of machine, component, physical device, computer storage medium or device in order to be interpreted by or provided to the processing device or to provide instructions or data. have. The software may be distributed over networked computer systems so that they may be stored or executed in a distributed manner. Software and data may be stored on one or more computer readable recording media.

The method according to the embodiment may be embodied in the form of program instructions that can be executed by various computer means and recorded in a computer readable medium. In this case, the medium may be to continuously store a program executable by the computer, or to temporarily store for execution or download. In addition, the medium may be a variety of recording means or storage means in the form of a single or several hardware combined, not limited to a medium directly connected to any computer system, it may be distributed on the network. Examples of the medium include magnetic media such as hard disks, floppy disks and magnetic tape, optical recording media such as CD-ROMs and DVDs, magneto-optical media such as floptical disks, And ROM, RAM, flash memory, and the like, configured to store program instructions. In addition, examples of another medium may include a recording medium or a storage medium managed by an app store that distributes an application, a site that supplies or distributes various software, a server, or the like.

Although the embodiments have been described by the limited embodiments and the drawings as described above, various modifications and variations are possible to those skilled in the art from the above description. For example, the described techniques may be performed in a different order than the described method, and / or components of the described systems, structures, devices, circuits, etc. may be combined or combined in a different form than the described method, or other components. Or even if replaced or substituted by equivalents, an appropriate result can be achieved.

Therefore, other implementations, other embodiments, and equivalents to the claims are within the scope of the claims that follow.

Claims (20)

In a method performed in a computer system,
Retrieving a set of IoT resources to provide a set of services, a set of functions required for a given task in a distributed internet of things environment
Including,
Searching for the IoT resource set,
Searching for the IoT resource set through a space-cohesive method considering the spatial distance between the user and the service, and the service and the service,
Generating a service retrieval plan based on space-cohesion requirements including rules relating to spatial distances; And
Searching for a service required for the task based on the service search plan, searching for a service that satisfies the space-aggregation requirement of the task, and then searching for the found service and other services maintaining space-aggregation
How to include. The method of claim 1,
Generating the service search plan,
Extracting space-coherent requirements specific to said task from a predefined task template
How to include. The method of claim 1,
The space-coherency requirement is expressed based on the ontology model and extracted using rule-based reasoning.
Characterized by the above. The method of claim 1,
Generating the service search plan,
Instantiating the service retrieval plan to the graph using a search strategy that guides traversal after expressing the space-coherency requirement as a graph abstracting the spatial location and relationship of the service
How to include. The method of claim 4, wherein
The search strategy is a spanning tree algorithm for configuring a path for searching for a child service from a parent service and a service priority function for assigning priority to each service according to the importance of the service. Consisting of
Characterized by the above. The method of claim 4, wherein
Searching for the IoT resource set,
Retrieving an IoT resource necessary to realize a service related to the task by propagating a service search request from a higher service to a lower service according to the service search plan instantiated in the graph
How to include. The method of claim 6,
Searching for the IoT resource,
Searching for a candidate IoT resource capable of providing the lower service with respect to the upper service and selecting an IoT resource having the closest spatial distance among the candidate IoT resources
How to include. The method of claim 1,
Searching for the IoT resource set,
Monitoring a space-aggregation state of the retrieved service to handover at least some of the retrieved services
How to include. The method of claim 8,
The transferring step,
IoT that does not meet the space-aggregation requirement according to an objective function that periodically checks whether the IoT resources selected for the task meet the space-coherency requirement and minimize the number of IoT resources to be handed over for a period of time Transitioning Resources to Other IoT Resources
Characterized by the above. The method of claim 1,
Searching for the IoT resource set,
Selecting a service required for the task based on a policy learned through machine learning for a service available by dynamic changes in the IoT environment
How to include. The method of claim 10,
The policy is learned to minimize the number of handovers defined by the difference between the newly selected service set and the existing service set while maximizing the space-aggregation defined as a measure of how close the space distance between the user and the service is. that
Characterized by the above. The method of claim 10,
The policy may be implemented as a neural network using a state vector representing coordinates and speeds of a user, a state vector representing coordinates and speeds of a service, and a relationship vector representing relative positions and speeds of a user and a service.
Characterized by the above. In a method performed in a computer system,
Discovering a set of IoT resources to provide a set of services, a set of functions required for a given task in a distributed IoT environment.
Including,
Searching for the IoT resource set,
Extracting space-aggregation requirements related to spatial distances between users and services and between services and services;
Generating a service search plan by expressing the space-coherency requirement as a graph abstracting the spatial location and relationship of a service and then instantiating it in the graph using a search strategy guiding traversal; And
Searching for IoT resources required to realize a service related to the task by propagating a service search request from a higher service to a lower service according to the service search plan
How to include. In a computer system,
At least one processor implemented to execute computer-readable instructions
Including,
The at least one processor,
The process of discovering a set of IoT resources to provide a set of services, a set of features required for a given task in a distributed IoT environment.
To process
The process of searching for the IoT resource set,
The IoT resource set is searched through a space-aggregation method considering a spatial distance between a user and a service, and a service and a service.
Generating a service discovery plan based on space-cohesion requirements including rules relating to spatial distances; And
Searching for a service required for the task based on the service search plan, searching for a service that satisfies the space-aggregation requirement of the task, and then searching for the service and other services maintaining space-aggregation
Computer system comprising a. The method of claim 14,
The process of generating the service search plan,
Instantiating the service retrieval plan to the graph using a search strategy for guiding the traversal after expressing the space-coherency requirement as a graph abstracting the spatial location and relationship of the service
Computer system comprising a. The method of claim 15,
The search strategy includes a spanning tree algorithm for configuring a path for searching for a lower service from a higher service and a service priority function for assigning priority to each service according to the importance of the service.
Computer system characterized in that. The method of claim 15,
The process of searching for a service required for the operation,
Searching for IoT resources required to realize a service related to the task by propagating a service search request from a higher service to a lower service according to the service search plan instantiated in the graph
Computer system comprising a. The method of claim 17,
The process of searching for the IoT resource,
Searching for a candidate IoT resource capable of providing the lower service with respect to the upper service and then selecting an IoT resource having the closest spatial distance among the candidate IoT resources
Computer system comprising a. The method of claim 14,
The process of searching for the IoT resource set,
Monitoring the space-aggregation state of the found service and handing over at least some of the found services
Computer system comprising a. The method of claim 14,
The process of searching for the IoT resource set,
Select a service required for the above task based on a policy learned through machine learning for the service available by the dynamic change of the IoT environment,
The policy is learned to minimize the number of handovers defined by the difference between the newly selected service set and the existing service set while maximizing the space-aggregation defined as a measure of how close the space distance between the user and the service is. that
Computer system characterized in that.

Images