Translation of the Mutation Operator from Genetic Algorithms to Evolutionary Ontologies

Recently introduced, evolutionary ontologies represent a new concept as a combination of genetic algorithms and ontologies. We have defined a new framework comprising a set of parameters required for any evolutionary algorithm, i.e. ontological space, representation of individuals, the main genetic operators such as selection, crossover, and mutation. Although a secondary operator, mutation proves its importance in creating and maintaining evolutionary ontologies diversity. Therefore, in this article, we widely debate the mutation topic in evolutionary ontologies, marking its usefulness in practice by experimental results. Also we introduce a new mutation operator, called relational mutation, concerning mutation of a relationship through its inverse. Keywords—Evolutionary ontologies; Genetic algorithms; Mutation; Ontology


I. INTRODUCTION
Evolutionary ontologies (EO) reprezent a new concept, introduced very recently by Matei et al. in [1].Vast and complex information used in artificial intelligence (AI) increasingly requires the use of ontologies as a manifestation of knowledge.But static information is of no use in the areas of AI, always subjected to change.Therefore evolutionary ontologies are the next natural step that is required to be made in AI.
EO are genetic algorithms using ontologies as individual items instead of classical data structures such as strings of bits, different values (real numbers, characters, objects) or programs.Also in EO is followed the pattern of the evolutionary process: it is selected an initial population that undergoes genetic operators such as crossover and mutation, then the offsping are subjected again to selection for resuming the algorithm until the condition of the problem to be solved is fulfilled or the maximum number of epochs is reached.
Although originated in classical genetic operators, crossover and mutation that are used in evolutionary ontologyies are new operators designed to meet the needs of complex structuring of knowledge contained in ontologies.
The genetic operators of evolutionary ontologies were introduced in [1], but was only traced the outline.The involvement of mutation in evolutionary ontologies diversity requires the detailing of the operator, which is the purpose of this article.
The rest of the paper is organized as follows: section II contains references to the genetic mutation operator and to the ontologies, but we have to emphasize that the two concepts are first used together in this article.Section III introduces mutation operators for evolutionary ontologies, the absolute novelty being relational mutation.In section IV we demonstrate the utility of mutation operators in practice, on an application for automatically generated scenes.Finally, the conclusions are marked in section V.

II. RELATED WORK
Imitating the biological model, genetic mutation operator changes the offspring resulting from crossover of the chromosomes [2].Often, genetic algorithms tend to block during searching the solution at a local optimum.The purpose of the mutation is to prevent this by not allowing the population to become too similar [3].
Mutation operator does not apply to all chromosomes, but a certain percentage of the population, called mutation rate [4].Sahoo et al. [5] state that mutation rate generally ranges between 0.05 and 0.02, but that sometimes is calculated as 1/n, where n is the number of chromosomal genes.Mutation rate is an important parameter of genetic algorithms, because, as Cao et al. show in [6] and Maaita et al. in [7], too many or too few mutations adversely affect convergence.
Mutation operator depends on the chromosome coding technique [8].For the binary representation is used, in particular, bit-flipping mutation [9], which consists in changing the values of some genes from 0 to 1 or vice versa [10].
For the integer encoding is used the random resetting mutation operator, where the value of a gene is replaced by a value chosen at random from an allowed range [11] or creep mutation, where a gene value is increased or decreased by a small value [12].
Permutation encoding involves chromosome representation as a string of integer or real values [13].The most suitable mutation operators for this type of encoding are swap mutation and inversion mutation [14].Under the swap mutation, two randomly chosen genes interchange their values [15].Regarding inversion mutation, two random points are selected within the chromosome and all the genes between the two points are reversed [15].www.ijacsa.thesai.orgUniform and non-uniform mutation are two types of mutations used for real encoding of the data.The positions of the genes uniform mutated are chosen with equal probability [16], and the values of these genes are replaced with uniform random numbers [17].Introduced by Michalewicz and presented in [18], non-uniform mutation, is to explore solutions space uniformly at first, and finally to become local search.
If we discuss coding tree, we meet subtree mutation, where a randomly selected subtree is replaced by another randomly created subtree (the process is broadly described in [19]) or point mutation, which changes a randomly selected node with a another node [20].
Although, so far, the mutation was considered a secondary genetic operator, Lehre and Yao proved in [25] that there is a close link between mutation and selection, which influences the running time of genetic algorithms.Moreover, mutation is such an important genetic operator, that significant research has been done for implementing it in different programming languages, such as C++ [26].Also, mutation was used with particle swarm optimization technique [27], whose role is to optimize the difficult problems of mathematics in continuous or binary space [28].Lastly, the importance of mutation operator is emphasized in practical applications of genetic algorithms, like the ones regarding the alignment of multiple molecular sequences [29], the detecting of human faces in an image with complex background [30] and the modeling of neural image compression [31].
The multitude of information requires the use of new data structures, enabling knowledge sharing and reuse, therefore, in recent years there has been an increase in the use of ontologies [32].An ontology can be seen as a set of related concepts [33].
Matei et al. used, for the first time, the ontologies in the context of genetic algorithms, introducing the concept of evolutionary ontologies in [1].Our goal was to enrich the ontology knowledge already held, this being achieved by applying genetic operators on ontologies.Due to the complex nature of mutation operator, we believe that the general framework introduced in [1] is not enough, therefore we detail mutation in this article.

III. MUTATION IN EVOLUTIONARY ONTOLOGIES
In [1] was defined the operating framework of ontologies under the aegis of the evolutionary algorithms.The ontological space (onto-space) is an ontology that includes all the elements of a domain of knowledge at information level with all their characteristics and relationships.Formally, an onto-space is defined as follows: where C is the set of classes, P is the set of properties and I is the set of instances.
An individual of the evolutionary ontologies is a subset of the ontology, meaning where SC ⊂ C is a subset of classes in OS, SP ⊂ P is a subset of properties in OS and SI ⊂ I is a subset of instances in OS.
A population consists of (µ) such individuals, but not necessarily cover the whole onto-space, therefore Due to the complex nature of individuals, is required the instantiation mutation, resulting three types of mutation operators, namely class mutation, instance mutation and property mutation.

A. Class mutation
The set of classes of onto-space, C, can be seen as a reunion of all ontology classes where n c is the number of classes in the ontology.
In an ontology, therefore also in onto-space, classes are organized hierarchically [34], a class whether or not containing one or more subclasses.Any class or subclass C i may have one or more subclasses, which in turn can have subclasses, going as deep as much require the domain of knowledge that is represented.
where n ci is the number of subclasses of class C i .
Any class or subclass C i can be regarded as a set of instances, composed by its own instances and all instances of all its subclasses.
where n instc i is the number of the own instances of class C i .
Mutation of a class C i takes place by replacing all its own instances with the instances of a randomly chosen subclass of class C i .In other words, the instances ninst c i k1=1 I i.k1 will be replaced by the instances ninst q 1 k3=1 I i.q1.k3 , where q 1 is a random number with values in the range [1, n ci ] representing the serial number of the selected subclass.

B. Instance mutation
The set of instances of onto-space, I, is the reunion of all ontology instances where n inst is the number of instances in the ontology.
The instances are grouped together in classes, as can be seen in ( 6).We consider an instance I i.q1 , where q 1 ∈ www.ijacsa.thesai.org[1, n instc i ], of a class C i .Mutation of the instance I i.q1 means replacing it with another instance of class C i , namely I i.q2 , where q 2 ∈ [1, n instc i ], q 2 = q 1 and I

C. Data Property Mutation
In an ontology, thus also in onto-space, are two types of properties: data properties and object properties [35].We note with P di a data property, ∀i ∈ [1, n p d ], where n p d is the number of data properties in OS and with P oj an object property, ∀j ∈ [1, n po ], where n po is the number of object properties in OS.Therefore, the set of onto-space properties is defined as follows: The mutation may be applied differently, depending on the type of property.
A data property is characterized by a data type, that indicates the kind of value for the corresponding instance, which have such property data.Typically, the data types most commonly used for data properties are numerical types and boolean.
We consider a data property P di , with i ∈ [1, n p d ].If I j , with j ∈ [1, n insti ] is one of the instances that have this data property, and the value corresponding to I j for property P di is val, with val ∈ [val 1 , val k ], then applying mutation on data property means changing the val value.Changing the val value depends on the data type of the property P di , as follows: 2) If data property P di has a real data type, then there are two possibilities: a) first possibility is similar to the first possibility for integer values, hence (9) takes place also in this case b) the val value will be changed by adding a value (positive or negative), based on non-uniform mutation, ie where r is a uniformly distributed random number [0, 1], g is the current generation, G is the maximum number of generations, b is the degree of non-uniformity usually of value 5, moreover when α > 0, β = val k and when α < 0, β = val 1 (11) 3) If data property P di has a boolean data type, then mutation acts as a switch by changing the value val with its complement, ie

D. Object Property Mutation
An object property is designed to establish relations between the classes of the onto-space and thus between their instances.Each object property has behavior of a binary relation [36], so each object property is defined on a domain and has values in a range.
We consider an object property P oj , with j ∈ [1, n po ], which has the domain, respectively the range one class or a class reunion.
where n domj is the number of domain classes and n rj is the number of range classes for object property P oj .
According to (6), an instance of the domain is and an instance of the range is For the sake of simplicity, we note, the P oj domain with D j , the P oj range with R j , an instance of the domain with I i1 , an instance of the range with I i2 , the results being the same regardless of chosen notations.Thus where I i1 ∈ D j and I i2 ∈ R j .
The inverse of the P oj , if any, is P − oj with the domain R j and the range D j , therefore Applying mutation operator on the object property P oj means one of the following: 1) Replacing the object property P oj with its inverse P − oj , if it exists, very suitable for spatial relations, www.ijacsa.thesai.orgWe call this type of mutation, relational mutation, but it does not apply in all conditions.The relations ( 14) and ( 15) occur before mutation.After mutation: with I i1 ∈ R j and I i2 ∈ D j .So I i1 and I i2 belong both to the domain and range, when applying relational mutation.For relational mutation to be valid, must occur: D j = R j , in which case relations P oj and P − oj swap or D j R j = ⊥, in which case the relational mutation applies only when relations link instances of intersection.
Of course that relational mutation may also occur in other particular cases, which must be checked manually to match the onto-space rules, but those shown in ( 17) may be automatically applied as imposed by evolutionary ontologies.2) Changing the object property P oj with another object property P o , which is not part of the onto-space, but suitable for domain knowledge, so as to have the same domain and range as the object property P oj .
P oj = P o , so that P o / ∈ OS, but If the object property P oj has inverse, we identify two situations: a) The new object property P o has inverse, in which case the inverse of object property P o will substitute the inverse of object property P oj ; b) The new object property P o has no inverse, in which case the inverse of object property P oj will be deleted from the onto-space.3) Replacing one of the instances I i1 or I i2 with another instance I i1 , respectively I i2 , belonging to the domain, respectively to the range.
starting from I i1 P oj I i2 , is obtained by the application of mutation The third situation may seem similar to instance mutation.However, is another type of mutation because in the case of instance mutation, an instance I i is replaced by another instance of the same class as I i , while in the case of object property mutation, an instance is replaced by another instance of a class reunion, which is the domain or the range of the object property.

IV. EXPERIMENTAL RESULTS
The concept of evolutionary ontologies was applied on user centered automatically generated scenes application, like in all previous similar experiments, reported in [37], [38].This way, the methodology is consistent throughout all the experiments.Cycle of the algorithm takes place in the following stages: it sets the initial population as a list of 10 randomly generated scenes.For each scene it selects a frame.We have considered  The first set of experiments were designed having in mind the importance of the mutation operator in the economy of evolutionary ontologies.The results are summarized in Table I.Two successive lines of the table, in column Epoch, denote the epochs range for which we have recorded values.
From Table I it is noticeable that the mutation improves the diversification with 7% to 24%, which is significant comparing with the complexity of the individuals (which is the number of components of a scene and the relationships between them).
A next set of experiments targeted the influence of the completely new type of mutation, namely relational mutation.The results are summarized in Table II.The header of Table II has the same meaning as the header of Table I.
The inversion itself brings interesting diversification, counting for up to almost 8%, which is significant for a simple operator, taking into account that it can be applied only for invertible relations.A graphical representation of the results reported in Table II is depicted in figure 3. • classes; • instances; • data properties; • object properties (class relationships).
The most complex mutation operators are at the level of object properties, where we define three specific operators: • replacing the whole relation with its inverse when this is possible; • replacing the property itself; • changing relations between the instances.
The complete novelty of the article is the application of the inverse relationships as relational mutation in the context of evolutionary ontologies.This type of mutation has proved highly efficient in application for automated generation of scenes, causing the innovations in scenes due to its mirror effect.
As future work we intend to use relational mutation in an application for automatic design of industrial products, where its role is to maintain the diversity of relationships between components of products.

1 )
If data property P di has an integer data type, then there are two possibilities: a) the val value will be changed with val , another value from the range [val 1 , val k ], ie val = val , where val ∈ [val 1 , val k ] (9) b) the val value will be changed by adding a value (positive or negative), which is part of a symmetrical distribution to zero, ie val = val + α, where α > 0 or α < 0 such that val + α ∈ [val 1 , val k ] (10)

Fig. 3 :
Fig. 3: The median, minimum and maximum number of differences in the two cases: (a) without inverse; (b) with inverse as mutation

TABLE I :
The number of differences between epochs without, respectively with mutation Epoch Without mutation With mutation Improvements Median Min.Max.Median Min.Max.Median Min.Max.

TABLE II :
The number of differences between epochs when using a simple mutation, respectively applying also the inverse operator