Kensuke Baba
email: baba.kensuke.060@m

Serina Egawa
email: s-egawa@soc.ait.kyushu-u.ac.jp

A Data Structure for Efficient Biometric Identification

ou non, émanant des établissements d'enseignement et de recherche français ou étrangers, des laboratoires publics ou privés.

Introduction

Personal authentication is an essential issue in many systems, especially, biometric authentication is an important technology to compensate some weaknesses of token-and knowledge-based authentication [START_REF] Jain | Introduction to Biometrics[END_REF]. With the spread of computers and networks, the number of persons who use each application system is supposed to become huge. For authentication based on biometric information, there exist two possible procedures of matching, that is, verification and identification [START_REF] Jain | Introduction to Biometrics[END_REF]. Identification searches for the target person, while verification confirms that the target person is a particular person. Identification requires a long processing time and it becomes more conspicuous in systems with a large number of users.

The aim of this paper is an acceleration of personal identification with biometric images. If biometric images are formalized as numerical vectors, the identification can be reduced to the problem of nearest neighbor search, that is, to search a set of vectors for the most similar vector to the input vector. Hence, an approach to the aim is an acceleration of nearest neighbor search by a suitable data structure [START_REF] Friedman | An algorithm for finding best matches in logarithmic expected time[END_REF] or an approximation [START_REF] Indyk | Approximate nearest neighbors: towards removing the curse of dimensionality[END_REF]. In some practical systems, however, the process of image matching is implemented as a distinct module and treated as a black box whose input is a pair of two images and output is a similarity between the two images. In such a situation, identification should be conducted on the basis of image comparisons. In this paper, we focus on such comparisonbased algorithms for identification with biometric images.

If we arrow some deterioration of accuracy, we can consider a method that searches for an image whose similarity with the input image is larger than a given threshold, instead of the most similar image. In this method, the processing time can be reduced by stopping the search when a similar image is found. Maeda et al. [START_REF] Maeda | Identification algorithm using a matching score matrix[END_REF] proposed an identification algorithm (MSM) that reduces the number of image comparisons in the linear search. The main idea of the algorithm is that, for N images that were registered for authentication, a similarity between any pair of the registered images is calculated in advance, and then the order of comparisons with the input image is decided according to the N × N matrix of the similarities. They reported that the average number of comparisons is experimentally O( √ N ), while that in the linear search is O(N ). However, the process to choose the image for each comparison is comparing the N row vectors in the matrix, hence the processing time of a single image comparison is proportional to N . Therefore, the total processing time is estimated to be proportional to N 3/2 on the assumption that the number of comparisons is O( √ N ) [START_REF] Egawa | Evaluation of acceleration algorithm for biometric identification[END_REF]. In this paper, we propose an identification algorithm with biometric images as an improvement of MSM. The main idea is to prepare the order of image comparisons statically by a kd-tree [START_REF] Friedman | An algorithm for finding best matches in logarithmic expected time[END_REF] instead of the dynamic O(N ) computation from the N × N matrix. By the assumption of comparison-based identification, any algorithm requires O(N ) comparisons of images. The time complexity of the novel algorithm is no more than O(N ). Additionally, we examine the processing time and the accuracy of the three identification algorithms, the novel one, MSM, and the linear search, with the features extracted by Scale-Invariant Feature Transform (SIFT) [START_REF] Lowe | Object recognition from local scale-invariant features[END_REF][START_REF] Lowe | Distinctive image features from scale-invariant keypoints[END_REF] from practical palmprint images. We confirm that the novel algorithm reduces the number of image comparisons as MSM and does not worsen the accuracy.

Preliminaries

The problem of personal identification with biometric images is called identification. In identification, each image corresponds to a person. The input of identification consists of an image (called an input image) and a set of images (called a set of templates). The output is the name of the person judged to correspond to the input image or "null" if the person of the input image is judged to be not included in the persons of the templates.

In the rest of this paper, we consider comparison-based algorithms for identification. We suppose that an idea of similarity on biometric images is given and only the similarity of images can be obtained as leads for identification. Then, the linear search algorithm is, for a given threshold, -Compare the input image with each template in the set successively in an order; -If a template whose similarity with the input image is not less than the threshold is found, then output the person of the image and terminate;

-If the similarities with every templates are less than the threshold, output "null" and terminate.

For the accuracy of an identification algorithm, we consider "the rate that the person who corresponds to the output image is different from the person of the input image", and this rate is called the error rate (ER) of the algorithm.

The Algorithm

We propose an identification algorithm that reduces the number of image comparisons in the linear search algorithm by a tree for deciding the order of image comparisons.

Let N be the number of templates and t i a template for 1 ≤ i ≤ N . First, we make the N × N matrix whose (i, j)-element m ij is the similarity between t i and t j for 1 ≤ i, j ≤ N . Then, we construct a tree that decides the order of image comparisons as follows.

1. Choose ℓ templates for the initial comparisons; 2. Construct a kd-tree for the N ℓ-dimensional vectors obtained by 1; 3. Add an order of image comparison to each leaf of the tree in 2 on the basis of Euclidean distance on the ℓ-dimensional vectors.

Let t r1 , t r2 , . . . , t r ℓ be the ℓ templates chosen in the process 1. In process 2, the kd-tree is constructed for the N ℓ-dimensional vectors

(m 1r1 , m 1r2 , . . . , m 1r ℓ ), (m 2r1 , m 2r2 , . . . , m 2r ℓ ), . . . , (m N r1 , m N r2 , . . . , m N r ℓ ),
and each of the N leaves corresponds to a unique template. In process 3, an order of image comparisons is expressed as a list of the N templates, and the order for the leaf of t i is decided as follows.

-The first template is t i ; -The rest is the list of the templates except for t i such that the jth template is nearer to t i than (j + 1)th template for 1 ≤ j ≤ N -2, where the distance between t i and t j is the distance between (m ir1 , m ir2 , . . . , m ir3 ) and (m jr1 , m jr2 , . . . , m jr3 ). With the previous tree, identification is conducted as follows.

1. Compare the input image with the ℓ templates and obtain an ℓ-dimensional vector; 2. Search the nearest vector to the obtained vector in the constructed tree, and decide the order of comparisons; 3. Conduct the linear search algorithm with the decided order.

The process 1 requires ℓ comparisons of images. Generally, nearest neighbor search with a kd-tree in N ℓ-dimensional vectors needs O(N 1-1/ℓ ) time. In the process 3, since we have a fixed order of image comparisons, the processing time of a single comparison is constant. Therefore, the total processing time of the proposed algorithm is no more than O(N ). The practical number of image comparisons in the proposed algorithm is examined experimentally in the following section.

The proposed algorithm in Section 3 was applied to practical palmprint images and evaluated in terms of the ER and the number of image comparisons.

Image Matching

We consider a matching of SIFT features for the comparison of palmprint images. This subsection defines the similarity on palmprint images for identification. In this paper, the region of interest on each palmprint was extracted as the circle that covers the maximal part on a palm as [START_REF] Egawa | Evaluation of acceleration algorithm for biometric identification[END_REF].

SIFT is one of the popular methods for image matching and object recognition and the detailed mechanism can be found in [START_REF] Lowe | Object recognition from local scale-invariant features[END_REF][START_REF] Lowe | Distinctive image features from scale-invariant keypoints[END_REF]. SIFT translates an image into a set of key points and each key point has a vector as its feature. Then, a comparison of two images is done by matching two sets of key points. There exist several possible procedures for the matching of key points. In this paper, the similarity on images (that is, sets of key points) is defined as follows. Let P and Q be two sets of key points and v(p) the feature vector of a key point p. We consider q p , p q , and m such that -For any p ∈ P , q p ∈ Q satisfies that ∥v(q p ) -v(p)∥ is the smallest in Q.

-For any q ∈ Q, p q ∈ P satisfies that ∥v(p q ) -v(q)∥ is the smallest in P .

m is the number of the pairs of p ∈ P and q ∈ Q such that q p = q and p q = p.

Then, the similarity of two images whose features are respectively P and Q is defined to be m/ max{|P |, |Q|}.

Results

The experiments were conducted on the PolyU Palmprint Database [START_REF]PolyU Palmprint Database[END_REF]. For the practical process of SIFT, the function "SiftFeatureDetector" in OpenCV [START_REF]OpenCV[END_REF] was used. The parameter "threshold" of the function was fixed at 0.01 and the other parameters were set to the default values according to the results of some preparatory experiments about the processing time and the error rate of matching. In addition to the proposed algorithm, MSM [START_REF] Maeda | Identification algorithm using a matching score matrix[END_REF] and the linear search algorithm were applied to a sample set of palmprint images. The set contains 1, 200 images that consists of 8 images times 150 persons. We separated the set into two sets of 4 × 150 images for templates and input images, and repeated each experiment with swapping the sets. The number of image comparisons in MSM depends on the choice of the pair of images for the first comparison, and that in the linear search depends on the order of templates in addition to the choice. Therefore, identification for the two algorithms were repeated for any combination of the initial pair (600 × 600 patterns), and moreover a cyclic order was chosen randomly and fixed for the repetition in the linear search. As for the proposed algorithm, the number of the repetition was 600. We fixed the number of initial comparisons ℓ = 10 in the proposed algorithm and 10 initial templates were chosen randomly. Figure 1 shows the ERs and the number of image comparisons in the proposed algorithm with 10 initial comparisons, MSM, and the linear search algorithms at the different values of the threshold for the image similarity. The optimum ERs and the numbers of image comparisons at the optimum points are summarized in Table 1. The results report that the ER of the proposed algorithm is small compared to the linear search algorithm and almost same as MSM. The number of image comparisons in the proposed algorithm was drastically reduced from the linear search algorithm and is slightly larger than MSM.

Conclusion

This paper proposed an efficient algorithm for personal identification with biometric images as an improvement of the algorithm by Maeda et al. (MSM) [START_REF] Maeda | Identification algorithm using a matching score matrix[END_REF]. We replaced the O(N ) process required for every image comparisons in MSM into an overhead of a single O(N ) process, where N is the number of the templates. The proposed algorithm, MSM, and the linear search algorithm were evaluated with practical palmprint images in terms of the processing time and the accuracy. By the evaluation, we confirmed that the proposed algorithm can reduce the number of image comparisons from the linear search algorithm with no loss of the accuracy similarly as MSM.

In the experiment of the proposed algorithm, the number of initial comparisons was fixed to be 10, however the optimum number in the senses of the ER and the number of comparisons is not clear. To make clear the relation between the optimum number and the number of templates is one of our future work.

Fig. 1 .

 1 Fig. 1. The ERs and the numbers of image comparisons in the proposed algorithm, MSM, and the linear search algorithm.

Table 1 .

 1 The optimum ERs and the numbers of image comparisons at the point of the optimum ERs in the proposed algorithm, MSM, and the linear search algorithm. * is the rate against the number in the linear search algorithm.

		ER ♯comparisons ( * )
	linear search 24.9	417.3 (1)
	MSM	20.3	94.6 (0.23)
	proposed	20.2	123.4 (0.30)

Acknowledgement

This work was partially supported by the Grant-in-Aid for Young Scientists (B) No. 22700149 of the Ministry of Education, Culture, Sports, Science and Technology (MEXT) from 2010 to 2012 and CREST program of Japan Science and Technology Agency (JST) from 2008 to 2012.


Software Development Methods in the Internet of Things Selo

In the Internet of Things, billions of networked and softwaredriven devices will be connected to the Internet. They can communicate and cooperate with each other to function as a composite system. This paper proposes the AMG (abstract, model and generate) method for the development of such composite systems. With AMG, the development of software application can be done in an automatic manner, and therefore reducing the cost and develpment time. The method has been prototyped and tested with use cases.

Introduction

Today's Internet technology is mainly built for information sharing. Information providers, which typically are implemented as servers, provide information in the form of web pages that can be accessed by internet clients. In the Future Internet [START_REF] Papadimitriou | Future internet: The cross-etp vision document[END_REF], various independent networked computing devices from small devices (mobile devices, embedded systems, etc) to powerful devices (desktops and servers) may be easily connected to the Internet, in a plug and play manner. The Internet of Things is one of the popular terms illustrating the Future Internet.

From the software developer's point of view, the 'Thing' in the Internet of Things can be seen as all kinds of networked devices that are driven and delivered by (embedded) software. Considering that the device's functionalities are provided as services, we will have billions of services in the Internet (i.e., the Internet of Services). A typical example of an environment containing several (embedded) services is a smart home where a residential gateway is controlling and managing home devices with embedded services. In this type of dwelling, it is possible to maintain control of doors and window shutters, valves, security and surveillance systems, etc. It also includes the control of multi-media devices that are parts of home entertainment systems. In this scenario, the smart home is containing 1) WeatherModules that provide different data collection services (i.e., air temperature, solar radiation, wind speed, and humidity sensors), 2) Lamps that provide on-off and dimmer services, and 3) Media Renderers that provide playing of multimedia services, see Figure 1 below. Combining these independent services (i.e., embedded software) and promoting as a new application is a challenge. Unfortunately, traditional software engineering approaches are not fully appropriate for the development of service-based applications. There is an urgent need for developing comprehensive engineering principles, methodologies and tools support for the entire software development lifecycle of service-based applications [START_REF] Van Den | Software service engineering: Tenets and challenges[END_REF].

This paper proposes a software development method in the Internet of Things. The remainder of the paper is organized as follows: In Section 2 we present terms and definitions of a service and a service-based application. Then, in Section 3 we present the AMG method. Section 4 is devoted to related work. Finally, we draw our conclusions in Section 5.

Background

This section gives a background for the paper. It discusses the definition of a service and a service-based application.

What is a Service? A service can be defined in different ways. In [START_REF]Definition for the term (software) service, sector abbreviations and definitions for a telecommunications thesaurus oriented database[END_REF] for instance, a service is defined as asset of functions provided by a (server) software or system to client software or system, usually accessible through an application programming interface. Similar definitions as the one above appear in the context of middleware technologies such as Jini [START_REF] Cicirelli | Integration and interoperability between jini services andWeb services[END_REF], .NET [START_REF] Jizhe | Research and implementation of lightweight esb with microsoft .net[END_REF], or JXTA [START_REF] Yeager | Secure peer-to-peer networking: The jxta example[END_REF]. These definitions recognize services as a central element in the system implementation.

In this paper, referring to [START_REF] Assmann | Invasive software composition[END_REF] and [START_REF] Mcilroy | Mass-Produced software components[END_REF] a service is defined as a model of software unit. To get an overview of this definition, we have to look at the history of managing the complexity of software systems where a componentoriented architecture is considered as the solution for the complexity problem. Figure 2 illustrates a historical perspective of the use of different models to represent a software unit.

The idea of using software component as defined in [START_REF] Mcilroy | Mass-Produced software components[END_REF], can be considered as the birth of today's software component and can be seen as an architectural approach of building software systems. When Assembler was the only available programming language, a routine was considered the first model of software units. As the complexity of software systems was increasing a new model of a software unit called a module was introduced. A module is a simple model. However, a module is more abstract than a routine. Accordingly, objects, components and services can also be seen as models of a software unit. The differences between them are their abstraction levels, means of encapsulation and ownership. Software abstraction, encapsulation and reuse are the key points.

With software component-orientation in mind, a single software component might not work as an application. Therefore a composition system is needed. According to [START_REF] Assmann | Invasive software composition[END_REF], a software composition system has three aspects: component models, composition techniques and composition languages. Depending on the models of software unit, see Figure 2, different composition techniques and languages are required. These two aspects have influenced the development approaches and paradigms. For example, when we use objects as a model of a software unit to build a software system we call the paradigm object-oriented development. Accordingly, we have component-oriented development for component oriented-systems and service-oriented development for service-oriented systems. A general concept of service-oriented systems is well-known as Service-Oriented Architectures (SOA) [START_REF] Erl | Service-Oriented Architecture (SOA): Concepts, Technology, and Design[END_REF].

Service-based Applications Using the SOA concept, architecturally, software applications are built from compound, heterogeneous, autonomous software units called services. If it is the case, service compositions will be a common approach for the development of software applications in the Internet of Services. Software systems and applications are becoming service-based. We call this a service-based application.

A conceptual model of a service-based application is presented in Figure 3. It can be seen that a service-based application may use more than one service. It is shown also that a service can be classified either as Simple or Composite. In this paper, all services that will be composed are considered as a simple service. As mentioned earlier, a composite service is a type of a service-based application. It composes services and provides the combined functionality as new services. A service can also be classified either as Abstract or Concrete. An abstract service may have one or more concrete services or it may mean that the service will be implemented in the future. But for the composition of services, this paper considers only Concrete services (run-time services). Furthermore, services can also be classified either as a State-less or State-ful service. Web services can be considered as an example of stateless services, while UPnP services [START_REF] Jeronimo | UPnP Design by Example: A Software Developer's Guide to Universal Plug and Play[END_REF] can be considered as a kind semi state-ful services. UPnP devices use state variables to store the states of specific variables and inform those state changes to other UPnP devices.

The AMG Method

With regard to the software production, there are different approaches, which focus on how to specify, design, implement, test, and deploy software systems. They can be categorized as implementation-and model-oriented approaches. AMG is a model-oriented approach. Figure 4 shows the idea of the AMG-method.

The Abstraction Step

Specifying models of a service-based application is only possible if the models of the included (i.e., existing) services are in place. For this an abstraction process is required. The abstraction step consists of a transformation mechanism of service descriptions into graphical representations and source code. Using the illustrated concept earlier, from a service description (s), the abstractor produces a graphical service model (M s ) conforming to a selected modeling language and source code (C s ) conforming to a selected programming language. To automate the transformation process, existing service frameworks and APIs (e.g., the Web Service framework and API) are used.

Depending on the selected modeling language, different graphical representations (i.e., notations) can be used to represent the existing services. UML classes, CORBA components, Participants in SoaML, or SCA components are among them. However, it must be noted that within the context of domain-specific modeling (DSM), a graphical representation must relate to a real thing which in this case is the implementation of the service. Therefore, it is important to keep the relation (bindings) between graphical representations (i.e. service models) and source code (i.e. implementation for the service invocations). Fig. 6 shows the relation between a service description, its model, and source code. Different service frameworks and APIs have been developed using different programming languages and run on different platforms, helping developers to implement services. For example, in the Web services context there are Apache Axis (Java and C++), appRain (PHP), .NET Framework (C#, VB and .NET), etc. Therefore, a graphical representation of a service may have several implementations (i.e., source code). This source code may also use different programming languages and may run on different platforms.

An Example: UML classes. A UPnP device has two kinds of descriptions; device description and service description. A UPnP device can have several services that are in a UPnP service description called Actions. To automate the abstraction step we use transformation rules. Table below shows transformation rules to transform different properties in a UPnP service description into properties in an UML class. To construct the transformation rules, both UML and UPnP meta-models are required. However, the rules are very simple. For example, to present the class name, we use the name of the UPnP device. Obviously, other XML-based service descriptions (e.g., WSDL, DPWS) will use the similar process.

The Modeling Step

In software development, models are used to describe the structures and the behaviors of the software systems. The structure specifies what the instances of the model are; it identifies the meaningful components of the model construct and relates them to each other. The behavioral model emphasizes the dynamic behavior of a system, which can essentially be expressed in three different types of behavioral models; interaction diagrams, activity diagrams, and state machine diagrams. We use interaction diagrams to specify in which manner the instances of model elements interact with each other(roles)

Even though for model-driven development, state-machine diagrams are considered as the most executable models, we are still interested in using UML activity diagram and collaboration diagram. The reason is that from activity diagrams we can generate state machine diagrams [START_REF] Alexander | Engineering Reactive Systems: A Compositional and Model-Driven Method Based on Collaborative Building Blocks[END_REF]. The UML activity diagrams are used mostly to model data/object flow systems that are a common pattern in models. The activity diagram is also good to model the behavior of systems which do not heavily depend on external events.

AMG is a language-independent method. It is possible to use different existing modeling languages and different modeling editors. This is done by developing and implementing different service abstractors/presenters. The requirement is that the presenter must generate notations (i.e., abstract service models) that conform to the chosen modeling languages. Using the abstract service models (M s1 , M s2 , ..., M sk ), a service-based application can be expressed in a composition function f{M s1 , M s2 , ..., M sk }, where s1..sk are the included services in the service-based application.

An Example: UML Sequence Diagram. Using UML classes, the structure of a service-based application can be specified as a class diagram, while the behavior part can be defined using sequence diagram. Accordingly, the semantic follows the semantic of UML 2.0. Fig. 7 shows a UML model of the service-based application defined in the scenario. There are four UML classes that represent different existing services mentioned in the scenario.

The Generation Step

For model execution, we use code generation approaches instead of model interpretations. For this, we did not use any transformation language to generate code, but a Java program to transform models into texts (i.e., source code). The potential code generation from activity diagrams was studied in [START_REF] Bhattacharjee | Validated code generation for activity diagrams[END_REF] and [START_REF] Eshuis | A formal semantics for uml activity diagramsformalising workflow models[END_REF]. For a tool, Enterprise Architect from Sparx Systems [START_REF]Enterprise architect[END_REF] is an example for modeling tools that support code generation from activity diagrams.

The code generation process of a service-based application can be expressed as a generation function g[f {M s1 , M s2 , .., M sk } , C s1 .. sk , dev inf o] ⇒ code, where f {M s1 , M s2 , .., M sk } is the model of the service-based application, s1, s2 .. sk are the included services, C s1 .. sk are the connected code of the used service models (M s1 .. sk ), and dev inf o is the given device information (i.e., the capability and configuration information).

Code from the behavior parts is taken from the activity nodes. For this we adapt the generation method presented in [START_REF] Bhattacharjee | Validated code generation for activity diagrams[END_REF]. With regard to their method, an UML class can be considered as an entity that executes an external action. For example, for the decision node (i.e., the decision node with the airtemperature input) the following code is produces. To generate code from the structure, from each classes, one object is instantiated. Since the UML classes in this scenario are platform independent, the objects to be instantiated are depending on the platform selection.

Discussion

Service composition is gaining importance, as it can produce composite services with features not present in the individual basic services. However, the fact that different perspectives may have different definitions of a service, the definition of service composition may also be different. AMG considers a service is just a kind of software component model that has evolved from the older software component models (i.e., modules, objects, and components). With this definition, a services composition can be done in a similar way as a composition of software units that normally is done at design-time using bottom-up approaches.

AMG focuses on service composition at design-time. However, the abstraction step in the AMG can be extended to support run-time compositions. Conceptually, it would be possible to generate graphical service representation that can be used by end-users (i.e., run-time composition). In the ISIS project for example [START_REF] Su | Description of the ISIS Ecosystem Towards an Integrated Solution to Internet of Things[END_REF], ICE, an end-user composition, has been developed. A service in ICE is presented as a puzzle with either one input (trigger) or one output (action). A composition is done by connecting puzzles. Using a specific service abstractor, ICE puzzles for end-users and its source code for implementing service invocations can be generated.

For the composition of service component models (i.e., software units), composition techniques, and composition languages are required [START_REF] Assmann | Invasive software composition[END_REF]. In Web service context, the Web Service Business Process Execution Language (WS-BPEL) [START_REF] Ouyang | Formal semantics and analysis of control flow in WS-BPEL[END_REF] and the Web Services Choreography Description Language (WS-CDL) [START_REF] Juan | Automatic translation of ws-cdl choreographies to timed automata[END_REF] can be considered as a composition language. Within the OMG context, the Serviceoriented architecture Modeling Language (SoaML) [START_REF] Omg | Service oriented architecture modeling language (SoaML) : Specification for the UML profile and metamodel for services (UPMS)[END_REF] is another example of composition languages. Also in the Web services context, services orchestration and choreography are well-known service composition techniques. In the context of Service Component Architecture (SCA) [START_REF]Service component architecture[END_REF], wiring can also be considered as a type of composition techniques. For this reason, AMG method does not depend to any particular languages. This can be done by developing different abstractor for different target languages.

Abstracting software functionality into abstract graphical representation has also been studied by other researchers. For example, in [START_REF] Grønmo | Model-Driven web services development[END_REF] UML classes is used to abstract Web services. However, their work focused only on Web services and did not think other possible services. In [START_REF] Yermashov | Software Composition with Templates[END_REF], software components are visualized using graphical notations that developers can easily understand. They use a picture of a real device to present a software component. The integration is done by simply connecting components graphically. Obviously, the approach is only applicable for a specific domain. In contrast, the AMG method is domainindependent.

Conclusion

With regard to the complexity of software systems, the aims for both software composition and model-driven development (e.g. MDA) are similar in which they are used for managing the complexity of software systems and their development. Having benefited from these approaches, this paper propose the use of modeldriven development for the development of software applications in the Internet of Things. With this idea, the composition of services can be done using models at different abstraction levels, while the executable composite services can be generated automatically.

Fig. 1 .

 1 Fig. 1. Smart home services: A Scenario

Fig. 2 .

 2 Fig. 2. The historical perspective of the use of different models of a software unit.

Fig. 3 .

 3 Fig. 3. A conceptual model of service-based applications.

Fig. 4 .

 4 Fig. 4. The AMG (abstract, model, and generate) method.

Fig. 5 .

 5 Fig. 5. A conceptual model of model transformation.

Fig. 6 .

 6 Fig. 6. The relation between a service description, its model and source code

Fig. 7 .

 7 Fig. 7. A service-based application model specified is using a sequence diagram. The composed application will play music when a UPnPLight service is invoked, and will stop it on a certain value of weather parameter.