Manuel Bouillon
email: manuel.bouillon@irisa.fr

Eric Anquetil
email: eric.anquetil@irisa.fr

Supervision Strategies for the Online Learning of an Evolving Classifier for Gesture Commands

Touch sensitive interfaces enable new interaction methods like using gesture commands. To easily memorize more than a dozen of gesture commands, it is important to be able to customize them. The classifier used to recognize drawn symbols must hence be customisable, able to learn from very few data, and evolving, able to learn and improve during its use. This work studies different supervision strategies for the online training of the evolving classifier. We compare six supervision strategies, depending on user interaction (solicitation by the system), and self-evaluation capacities (notion of reject). In particular, there is a trade-off between the number of user interactions, to supervise the online training, and the error rate of the classifier. We show in this paper that the strategy giving the best results is to learn from data validated by the user, when the confidence of the recognition is too low, and from data implicitly validated.

I. INTRODUCTION

With the increasing use of touch sensitive screens, humancomputer interactions are evolving. New interaction methods have been designed to take advantage of the new potential of interaction that those new interfaces offer. Among them, a new concept has recently appeared: to associate commands to gestures. Those gesture commands [START_REF] Wobbrock | User-defined gestures for surface computing[END_REF][2] enable users to execute various actions simply by drawing symbols. Previous studies [START_REF] Li | Semicustomizable gestural commands approach and its evaluation[END_REF] [START_REF] Li | User and system crosslearning of gesture commands on pen-based devices[END_REF] have shown that enabling customization is essential to help user memorization of gestures. To use such gesture commands, a handwritten gesture recognition system is required. Moreover, if gestures are personalized, the classifier has to be flexible and able to learn with few data samples.

Gesture commands give rise to a cross-learning situation where the user has to learn and memorize the gestures and the classifier has to learn and recognize drawn gestures. Enabling customization of the gesture commands is essential for user memorization. On the other hand, enabling users to choose their own gestures may lead to commands with similar or strange gestures that are hard to recognize by the classifier. Moreover, we can't expect users to draw much more than a few gesture samples per class, so the recognition engine must be able to learn with very few data. Some template matching classifiers exist, like the $1 classifier [START_REF] Wobbrock | Gestures without libraries, toolkits or training: a $1 recognizer for user interface prototypes[END_REF] for instance, that don't require much training. However, such simple systems have limited performances, and don't evolve with the user writing style. For example, novice users usually draw gestures slowly and carefully, but as they become more and more expert, users draw their gestures more fluidly and rapidly. In that case, we want the classifier to adapt to the user, and not the other way round. More flexibility in a recognizer requires an online system, a system that learns on the run-time data flow.

Evolving classification systems have appeared in the last decade to meet the need for recognizers that work in changing environments. They use online learning to adapt to the data flow and cope with class adding (or removal) at run-time. This work uses such an evolving recognizer -namely Evolve [START_REF] Almaksour | Improving premise structure in evolving takagi-sugeno neuro-fuzzy classifiers[END_REF] [START_REF]ILClass: Error-driven antecedent learning for evolving takagisugeno classification systems[END_REF] -which is a first order fuzzy inference system. It can start learning from few data and then learns incrementally in real time from the run-time data flow, to adapt its model and to improve its performances during its use.

The online learning algorithm is a supervised algorithm that requires labeled data. In the context of gesture command recognition, the only way of knowing the true label of a gesture is to interact with the user. However, soliciting the user after each command cancel the very interest of gesture commands! The method we use consist first, to take advantage of implicit validations of recognitions by the user: if he continues his action without canceling or undoing the executed command, he implicitly validates the recognition. Secondly, we use the classifier self-evaluation capacity to solicit the user and obtain data true label when the confidence of the recognition is low.

The confidence measure of the classifier recognition can be of two kinds: an absolute measure for distance rejection or a relative measure for confusion reject. For the strategies presented in this article, we use an inner confidence measure evaluating the classifier confusion degree. This measure allows to reject data when they are between the classifier models of two classes. We are hence using confusion reject. This paper is organized as follows. The Section II presents the architecture of our evolving classifier, its incremental learning algorithm and the rejection capacity we introduced to develop our supervision strategies. We detail in Section III how our different strategies for the online training work, and their impact on user interactions. Then, we compare the different supervision strategies in a realistic experimentation in Section IV. Section V concludes and discusses future work.

II. EVOLVING FUZZY INFERENCE SYSTEM

This Section presents the evolving Fuzzy Inference System (FIS) on which this work is based [START_REF]ILClass: Error-driven antecedent learning for evolving takagisugeno classification systems[END_REF]. We quickly describe the architecture of a first order FIS. Next, we present the incremental learning algorithm we use for the online training of our classifier. Then, we details the confidence measure and rejection capacity we introduced to develop supervision strategies using user interactions.

A. System Architecture

We focus here on Fuzzy Inference Systems (FIS) [START_REF] Lughofer | Evolving fuzzy models: incremental learning, interpretability, and stability issues, applications[END_REF], with first order conclusion structure -so-called Takagi-Sugeno FIS [START_REF] Takagi | Fuzzy identification of systems and its applications to modeling and control[END_REF]. FIS have demonstrated their good performances for incremental classification of changing data flows [START_REF] Angelov | Evolving fuzzy-rule-based classifiers from data streams[END_REF]. Moreover, they can easily be trained online -in real time -and have a good behavior with new classes. In this section, we present the architecture of the evolving FIS Evolve [START_REF] Almaksour | Improving premise structure in evolving takagi-sugeno neuro-fuzzy classifiers[END_REF] that we use to recognize our gesture commands.

Fuzzy Inference Systems consist of a set of fuzzy inference rules like the following rule example.

Rule (i) : IF x is close to C (i) (1)
THEN ŷ(i) = (ŷ

(i) 1 ; . . . ; ŷ(i) c ) ⊤ (2)
where x ∈ R n is the feature vector, C (i) the fuzzy prototype associated to the i-th rule and ŷ(i)⊤ ∈ R c the output vector. Rule premises are the fuzzy membership to rule prototypes, which are clusters in the input space. Rule conclusions are fuzzy membership to all classes, that are combined to produce the system output.

1) Premise Structure: Our model uses rotated hyperelliptical prototypes that are each defined by a center µ (i) ∈ R n and a co-variance matrix Σ (i) ∈ R n×n (where n is the number of features).

The activation degree α (i) (x) of each fuzzy prototype is computed using the multivariate normal distribution.

2) Conclusion Structure:

In a first order FIS, rule conclusions are linear functions of the input:

ŷ(i)⊤ = (l (i) 1 (x) ; . . . ; l (i) c (x)) (3)
l (i) k (x) = x ⊤ • θ (i) k = θ (i) 0,k + θ (i) 1,k • x 1 + • • • + θ (i) n,k • x n (4)
The i-th rule conclusion can be reformulated as:

ŷ(i)⊤ = x ⊤ • Θ (i) (5)
with Θ (i) ∈ R n×c the matrix of the linear functions coefficients of the i-th rule:

Θ (i) = (θ (i) 1 ; . . . ; θ (i) c ) (6)
3) Inference Process: The inference process consists of three steps:

1) Activation degree is computed for every rule and then normalized as follows:

α (i) (x) = α (i) (x) r k=1 α (k) (x) (7)
where r is the number of rules. 2) Rules outputs are computed using Equation 5and system output is obtained by sum-product inference:

ŷ = r k=1 α (k) (x) • ŷ(k) (8)
3) Predicted class is the one corresponding to the highest output:

class(x) = arg c max k=1 (ŷ k ) (9)
Figure 1 represents a FIS with first order conclusion structure as a radial basis function (RBF) neural network.

B. Incremental Learning Process

Let x i (i = 1..t) be the i-th data sample, M i the model at time i, and f the learning algorithm. The incremental learning process can be defined as follows:

M i = f (M i-1 , x i ) (10)
whereas a batch learning process would be:

M i = f (x 1 , . . . , x i ) (11)
In our recognizer Evolve [START_REF] Almaksour | Improving premise structure in evolving takagi-sugeno neuro-fuzzy classifiers[END_REF], both rule premises and conclusions are incrementally adapted:

1) Rule prototypes are statistically updated to model the run-time data:

µ (i) t = (t -1) • µ (i) t-1 + x t t (12)
Σ (i) t = (t -1) • Σ (i) t-1 + (x t -µ (i) t-1 )(x t -µ (i) t ) t (13) 2)
Rule conclusions parameters are optimized on the data flow, using the Recursive Least Squares (RLS) algorithm:

Θ (i) t = Θ (i) t-1 + α (i) C (i) t x t (y ⊤ t -x T t Θ (i) t-1 ) (14) C (i) t = C (i) t-1 - C (i) t-1 x t x ⊤ t C (i) t-1 1
α (i) + x ⊤ t C (i) t-1 x t (15)
New rules, with their associated prototypes and conclusions, are created by the incremental clustering method eClustering [START_REF] Angelov | An approach to online identification of takagi-sugeno fuzzy models[END_REF] when needed.

x

C (1) C (r) Π Π Π Π Σ ŷ1 Σ ŷc θ (1) 1 θ (1) c θ (r) 1 θ (r) c . . . . . . . . . . . . first rule ŷ(r) c α (r) x ⊤ • θ (r) 1
Fig. 1. First order FIS as a radial basis function (RBF) neural network

C. Confidence Measure and Rejection Threshold

We use confusion reject principles to evaluate the system confidence of recognized labels. Usually, confusion reject is based on system output (membership to all classes). However, we try to detect confusion, to evaluate our model quality, at a very early stage of the online learning process. As a result, inference rules conclusions are still rough and unstable, and not very representative of the system confidence. Instead, we choose to use rules premises which are much more stable at this early stage of the online training. Even though every prototype participates in the recognition of every class, each prototype has been created by and is mainly associated with a single class. We use that fact to detect confusion when some gesture activates different prototypes at similar levels.

We use the Mahalanobis distance to compute the distance of a data sample x to the prototypes C (i) (defined by their center µ (i) and co-variance matrix

Σ (i) ). distance(C (i) , x) = (x -µ (i) ) ⊤ (Σ (i) ) -1 (x -µ (i) ) ⊤ (16)
From this distances, we compute similarity measures that are smoother than prototype activations.

similarity(C (i) , x) = 1 1 + distance(C (i) , x) (17)
With this similarity measures, we compute system confidence as:

conf idence = s f irst -s second s f irst (18)
Where s f irst and s second are the first and the second highest similarity values. A data sample is then signaled as confusing when its confidence is below a certain threshold.

The optimization of the rejection threshold is a multiobjective problem: we want to maximize both classifier performance and accuracy.

P erf ormance = N Correct /N T otal (19) Accuracy = N Correct /(N Correct + N Errors ) (20)
Where N Correct is the number of correctly classified gestures, N Errors is the number of incorrectly classified gestures, and N T otal is the total number of gestures. As the threshold increases, the number of rejected gestures raises and the number of classification errors reduces.A high threshold will yield many rejections, which will increase system accuracy, whereas a low threshold will yield only a few rejections, which will increase system performance. There is a trade-off between the classifier performance and accuracy.

To solve this trade-off, we must define the cost of an error of classification, and the cost of a rejection. One the one hand, a rejection will make the system ask the user to validate or correct the recognized label. On the other hand, an error of classification will force the user to cancel/undo his command and do it again. Our goal is to reject data that don't fit well into the classifier model, to reduce classification errors but also to improve its model. However, we don't want to reject too many data and solicit the user too often.

III. SUPERVISION STRATEGIES

In the context of gesture commands, users initialize the system with a few gestures per class (three in our experimentation). To improve gesture command recognition, the classifier learns incrementally during its use.

At the same time that the classifier is learning, so is the user: he has to memorize which gesture is associated with which command [START_REF] Li | User and system crosslearning of gesture commands on pen-based devices[END_REF]. In this cross-learning situation, different cases can happen:

Case A The user draws the right gesture which is rightly recognized: the intended command is executed; Case B

The user makes a mistake and draws a wrong gesture; Case C

The classifier makes a mistake and recognizes a wrong label; Case D The classifier rejects the gesture and asks the user to confirm or correct its recognition.

When either the user or the system makes a mistake, the command which is executed is not the one that was intended. The user has to cancel/undo that command and try again to do the one he wants. Data can be divided into four categories like shown in Figure 2. The online learning algorithm used to train the classifier during its use is a supervised algorithm. It is hence necessary to label run-time data. Different strategies can be used: implicit strategies, without interacting with the user, and explicit strategies, that solicit the user to obtain data true label.

A. Supervision strategies based on implicit labeling, without user interaction

The advantage of implicit strategies is that they don't disturb users during their use of gesture commands. In this Section, using reject isn't compulsory and the D category of Figure 2 can be empty.

1) Strategy S1: using recognized label:

A first and naive supervision strategy consists of labeling run-time data is to use the label recognized by the classifier, without soliciting the user. However, this labeling will contain mistakes each time gestures are wrongly recognized. In those cases (category C of Figure 2), the classifier will learn with this wrong label, which will reinforce his mistake and deteriorate his model.

2) Strategy S2: using recognized label when implicitly validated by the user (no learning otherwise):

In practice, when the user draws a gesture, it is recognized by the classifier and the corresponding command is executed. Two cases are then possible.

-The user cancels or undoes this command, either because it doesn't correspond to the gesture he has drawn (classification error), either because he has drawn a wrong gesture (memorization error), or just because he changed his mind.

-The user continues his actions, which is likely to indicate that the executed command suit his needs, he implicitly validates the recognition.

A second learning strategy is again to use the recognized label, but to learn only when the user implicitly validates it (by doing another command that cancel/undo). The classifier will learn from the data samples it has correctly recognized (category A of Figure 2), but it will not learn from his mistakes (category C), nor from the user mistakes (category B), rather than risking to learn with a wrong label. This strategy allows to be sure not to deteriorate the classifier model, but reduces the number of data that can be used for the online training. Furthermore, the classifier only learns from the data it can correctly recognize, learning from them is interesting but not as much as learning from data that are incorrectly classified.

B. Supervision strategies based on explicit labeling by user interactions

Learning from incorrectly recognized data requires to interact with the user to obtain the true label of the gesture he has drawn. It seems obvious that soliciting the user after each command would be very tedious for the user. We must carefully select the data samples we ask him to label. To do so, we use the classifier confidence measure to select the data samples that aren't well described by the classifier model, and from which it will be very beneficial to learn.

1) Strategy S3: supervision based on explicit labeling by user interaction in case of rejection (no learning otherwise):

A third strategy is to use the rejection capacity we introduced in our classifier Evolve to solicit the user from times to times, when the recognized label doesn't have a sufficient degree of confidence. By doing so, the classifier can learn from the gestures that are complex to recognize (category D of Figure 2), for which it would have probably made a mistake. On the other hand, as the number of rejections has to be kept as low as possible to minimize user solicitation, few data are available for the online training.

2) Strategy S4: supervision based on explicit labeling in case of rejection, and on the recognized label otherwise:

A fourth supervision strategy is to associate the previous strategy, of labeling by user interaction in case of rejection, with the implicit strategy based on the recognized label when no rejection (strategy S2). All the data (category A, B, C and D) are here used for the online training, but here again some data may be mislabeled (data sample not rejected but wrongly recognized).

3) Strategy S5: supervision based on explicit labeling in case of rejection, and on the recognized label if implicitly validated (no learning otherwise):

The fifth strategy is similar to the fourth, but without using data from categories B and C of Figure 2 because their label hasn't been validated neither explicitly nor implicitly. Only data from categories A (implicitly validated) and D (explicitly validated) are hence used for the online training. This choice takes out a few data that aren't used for learning, but allow to be sure not to deteriorate the classifier model by learning on potentially mislabeled data.

4) Strategy S6: supervision based on recognized label if implicitly validated and on user solicitation otherwise:

Finally, a last strategy can be to use recognized label if implicitly validated, and to solicit the user to get the correct label otherwise. However, user memorization rates vary a lot between users (from 60% to 100%) even if good in average for customized gestures (ILGDB group 1): 94.29% (but 80.02% for all ILGDB) [START_REF] Li | User and system crosslearning of gesture commands on pen-based devices[END_REF]. Users would be solicited very often: when they make a mistake (category B: 5.71%), when the recognizer makes a mistake (category C: 2.13%), and when data are rejected (category D: 10.53%). Moreover, users would also be solicited when they cancel/undo a command for another reason than a recognition or memorization error.

Table I synthesizes which categories of data are used by each supervision strategy.

IV. EXPERIMENTATION

Our objective is to improve our classifier recognition performances as much as possible, but without soliciting the user too often. We compared experimentally the six supervision strategies presented above, and a reference strategy without any online training, summarized below.

Strategy S0 No online learning (reference strategy); Strategy S1 Learning using the recognized label; Strategy S2 Learning using the recognized label if implicitly validated (no learning otherwise); Strategy S3 Learning using the user label if the gesture is rejected (no learning otherwise); Strategy S4 Learning using the user label if the gesture is rejected, and with the recognized label otherwise; Strategy S5 Learning using the user label if the gesture is rejected, and with the recognized label if implicitly validated (no learning otherwise); Strategy S6 Learning using the recognized label if implicitly validated, and using the user label otherwise (perfect labeling).

A. Evaluation Protocol

We evaluated the different supervision strategies on the ILG Data Base1 [START_REF] Renau-Ferrer | The ILGDB database of realistic pen-based gestural commands[END_REF] using the supplied HBF49 [START_REF] Delaye | HBF49 feature set: A first unified baseline for online symbol recognition[END_REF] feature set. ILGDB contains 6629 mono-stroke gestures, belonging to 21 classes, that have been drawn by 38 writers in an immersive environment. This database is very interesting for three reasons. First, gestures are chronologically ordered (in their drawing order) which enables to see the evolution of user writing styles with time. Second, class frequencies vary, from 5 to 17 samples per class (per writer). Third, for the majority of the database, gesture classes where freely chosen by the writers themselves. These three reasons make this database very realistic and representative of the real use of a handwritten gesture online classifier. Furthermore, the low number of samples per writer (less than 180), and per class (less than 20), makes this database a challenging benchmark for evolving classifiers. Some gesture samples invented by ILGDB writers are presented in Figure 3.

Drawn symbols are distributed into five phases for each writer. Phase 0 contains three symbols per class and is used to initialize the classifier. We have used phases 1 to 3 (∼ 90 symbols) for the recognizer online training. Then, we tested our classifier performances on phase 4 (21 symbols, one per class).

B. Rejection Threshold

The rejection threshold is quite difficult to estimate in our applicative context where we are learning from very few data samples. Moreover, each user chooses his own set of symbols/gestures, which may be quite complex to learn by the classifier. The rejection threshold must be automatically estimated for each user and his custom gesture set, and computed in a sufficiently simple and robust manner to yield good results with the few available data.

To estimate the rejection threshold, we chose to initialize our classifier on two of the three initialization samples per class, and to measure the recognition confidence on the third sample. We then compute the mean µ reco and standard deviation σ reco of the correctly recognized data and set the rejection threshold to one standard deviation below the mean: threshold = µ reco -σ reco .

A posteriori, we plotted the average error/reject curve in Figure 4 and place the operating point obtained with our threshold estimation method (2.51% of error and 7.39% of reject for the fifth strategy). This operating point is very close to the line of slope 0.5 (drawn in Figure 4), which represent two times more rejections than classification errors. This threshold is very satisfying if we consider that the cost of an error is twice the cost of a rejection, which seems very plausible. If that ratio between the error and rejection costs is different, the threshold can easily be adjusted to move the operating point to one side or another.

C. Supervision Strategies Based on Implicit Labeling, Without User Interaction

Results obtained with implicit strategies are presented in Table II. The first strategy (S1), that consist of learning with the recognized label, deteriorates recognition performances by 1.4% (12% of relative diminution) with respect to the reference strategy (S0) without online learning. Learning with mislabeled data is counterproductive, it is better not to learn at all! Still, learning on implicitly validated data improves recognition performances, by strengthening the classifier model. The second strategy (S2) reduces the error rates by 1.81% (16% of relative diminution).

D. Supervision Strategies Based on Explicit Labeling by User Interaction

Results obtained with explicit supervision strategies are presented in Table III. The third strategy (S3), which is soliciting the user to learn with the correct label for rejected data, reduces the error rate by 4.23% (37% of relative diminution). Being able to learn from the data that are complex and hard to recognize is very important to improve our classifier model. The fourth strategy (S4), which consist of learning from both rejected data (labeled by user interaction) and accepted data (with the recognized label), only improves very slightly recognition performances (by 0.50% or 7% relatively) with regard to strategy S3. The fifth strategy (S5), which associates strategies 2 and 3, allows to get even better performances than when learning from all the data with the correct labels (strategy S6). Learning from data of categories A and D only reduces the error rate by 0.63% (9% of relative diminution) with respect to strategy S4 which uses all data. Here again, it is better not to learn than learning from potentially mislabeled data. Moreover, this strategy only solicits the user for 7.39% of the data, whereas the sixth strategy (S6) requires user interactions for 16.4% of the data: 5.71% for memorization errors (category B), 1.63% for classification errors (category C), and 9.02% for rejection (category D).

Even if the costs of an error and a rejection are difficult to estimate, we can reasonably say that a rejection has a smaller cost than a recognition error. A rejection solicits the user to validate, or correct, the recognized label, whereas an error forces the user to cancel or undo his command and do it again. Table IV compares the cost of the fifth strategy to the one with perfect labeling (user solicitation on data from categories B, C and D from Figure 2) with regard to the error cost C e and rejection cost C r .

The fifth strategy, which doesn't use all the data for the online learning, has a lower cost for the user than the sixth strategy, where all data are used (with the correct labels). Finally, learning on data from categories B and C of Figure 2 is not interesting because it requires a lot of user interactions to label data that doesn't improve significantly our classifier model and performances.

V. CONCLUSION

Training a classifier for the recognition of gesture commands is an online learning situation that requires a supervision strategy to label run-time data. Different strategies can be used, some labeling data implicitly and others soliciting explicitly the user to get the correct labels. On the one hand, it is necessary to interact with the user to be able to label complex data and improve our classifier model efficiently. On the other hand, constantly soliciting the user is tedious, and considerably reduces the easiness of use of gesture commands. A compromise must be chosen between the number of user interactions and the number of recognition errors.

We have compared six different supervision strategies for the online learning of an evolving classifier. As a result, it is compulsory to correctly label data, at the risk of deteriorating the quality of the classifier model. Actually, it is better not to learn than to learn from potentially mislabeled data. It still remains fundamental to be able to learn from misrecognized data with their correct labels to improve the classifier performances. In particular, we use an inner confidence measure to solicit the user when some data don't fit with the classifier model, and that it will be very gainful to learn from it, but without interacting too often.

This work shows the importance of correctly labeling data in online learning situations, and the difficulty of this labeling task in the context of gesture commands. We also showed the interest of our inner confidence measure to select the data to be labeled, and we highlighted the error/reject (and hence user interaction) trade-off. We optimized our rejection threshold to yield twice as much rejection than classification errors because we believe errors are much more bothering than rejection.

Further optimizing the rejection threshold would require to carry out a complete user experiment to estimate more precisely the error and rejection costs. Moreover, it could be interesting to study the impact of a varying threshold on the error/rejection trade-off and the online learning of the classifier. Interacting with users more often at the beginning of the learning process could fasten the classifier learning, which would then yield less rejections. In the same way, the rejection threshold could be updated online to follow the improvement of the classifier model.

Fig. 2 .

 2 Fig.2. Data partitioning as a result of the user and system cross-learning

Fig. 3 .

 3 Fig. 3. Gesture samples of ILGDB (group 1: free gestures)

Fig. 4 .

 4 Fig. 4. A posteriori error/reject average plot.

TABLE I .

 I SUMMARY OF THE CATEGORIES OF DATA USED BY THE DIFFERENT SUPERVISION STRATEGIES (UI: USER INTERACTION)

		Category A	Category B	Category C	Category D
	Strategy S1	yes	yes	yes	yes (without UI)
	Strategy S2	yes	no	no	no
	Strategy S3	no	no	no	yes (with UI)
	Strategy S4	yes	yes	yes	yes (with UI)
	Strategy S5	yes	no	no	yes (with UI)
	Strategy S6	yes	yes (with UI)	yes (with UI)	yes (with UI)

TABLE II

 II

	.	RESULTS OF IMPLICIT SUPERVISION STRATEGIES,
		WITHOUT USER INTERACTION
		Error Rate	Non-Rejected Error	Rejection Rate
		Without Reject (%)	Rate (%)	(%)
	Strategy 0	11.5	4.01	18.0
	Strategy 1	12.9	8.27	8.65
	Strategy 2	9.69	3.88	10.1

TABLE III

 III

	.	RESULTS OF EXPLICIT SUPERVISION STRATEGIES, WITH
		USER INTERACTIONS
		Error Rate	Non-Rejected Error	Rejection Rate
		Without Reject (%)	Rate (%)	(%)
	Strategy 3	7.27	2.38	12.7
	Strategy 4	6.77	3.26	7.64
	Strategy 5	6.14	2.51	7.39
	Strategy 6	5.51	1.63	9.02

TABLE IV .

 IV COSTS OF STRATEGIES WITH REGARD TO THE ERROR COST Ce AND THE REJECTION COST Cr .

		error (%)	Solicitation (%)	Ce = Cr	Ce = 2 * Cr
	Strategy 5	2.51	7.39	9.90	12.4
	Strategy 6	1.63	16.4	16.4	18.0

Freely available: http://www.irisa.fr/intuidoc/ILGDB.html


User Interaction Optimization for an Evolving Classifier of Handwritten Gesture Commands

Manuel BOUILLON, Eric ANQUETIL, PeiYu LI, Grégoire RICHARD Université Européenne de Bretagne, France INSA de Rennes, Avenue des Buttes de Coesmes, F-35043 Rennes IRISA, CNRS UMR 6074, Campus de Beaulieu, F-35042 Rennes {manuel.bouillon, eric.anquetil, pei-yu.li, gregoire.richard}@irisa.fr Abstract-Touch sensitive interfaces enable new interaction methods, like using gesture commands. The use of gesture commands give rise to a cross-learning situation where the user has to learn and memorize the command gestures and the classifier has to learn and recognize drawn gestures. To easily memorize more than a dozen of gesture commands, it is important to be able to customize them. The classification task associated with the use of customized gesture commands is complex because the classifier only has very few samples per class to start learning from. We thus need an evolving recognition system that can start from very few data samples and that will learn incrementally to achieve good performance after some using time. This paper presents the impact of using rejection based user interactions to supervise the on-line training of the evolving classifier. The objective is to obtain a gesture command system that cooperates as best as possible with the user, to learn from its mistakes without soliciting him too often. To detect confusing classes we apply confusion reject principles to our evolving recognizer, which is based on a first order fuzzy inference system. A significant user experiment has been performed on 63 persons that validates our approach. This user experiment shows the interest of optimizing user interactions by taking into account the confusion detection capability of our recognition system.

I. INTRODUCTION

With the increasing use of touch sensitive screens, humancomputer interactions are evolving. New interaction methods have been invented to take advantage of the new potential of interaction that those new interfaces offer. Among them, a new concept has recently appeared: to associate commands to gestures. Gesture commands [START_REF] Wobbrock | User-defined gestures for surface computing[END_REF][2] enable users to execute various actions simply by drawing symbols. Previous studies [START_REF] Li | Semicustomizable gestural commands approach and its evaluation[END_REF] have shown that enabling customization is essential to help users' memorization of gestures. To use such gesture commands, a handwritten gesture recognition system is required. Moreover, if gestures are personalized, the classifier has to be flexible and able to learn with few data samples.

As we can't expect users to draw much more than a few gesture samples per class, the recognition engine must be able to learn with very few data samples. Some template matching classifiers exist, like the $1 classifier [START_REF] Wobbrock | Gestures without libraries, toolkits or training: a $1 recognizer for user interface prototypes[END_REF] for instance, that don't require much training. However, such simple systems don't evolve with the user writing style. For example, novice users usually draw gestures slowly and carefully, but as they become more and more expert, users draw their gestures more fluidly and rapidly. In that case, we want the classifier to adapt to the user, and not the other way round. More flexibility in a recognizer requires an on-line system, ie a system that learn on the run-time data flow.

Evolving classification systems have appeared in the last decade to meet the need for recognizers that work in changing environments. They use incremental learning to adapt to the data flow and cope with class adding (or removal) at run-time. This work uses such an evolving recognizer, Evolve [START_REF] Almaksour | Improving premise structure in evolving takagi-sugeno neuro-fuzzy classifiers[END_REF], which is a first order fuzzy inference system. It can start learning from few data and then learns incrementally in real time from the data flow that it tries to recognize, to adapt its model and to improve its performance during its use.

The on-line learning algorithm is a supervised algorithm that requires labeled data. In the context of gesture command recognition, the only way of knowing the true label of a gesture is to interact with the user. However, soliciting the user after each command cancel the very interest of gesture commands! Our method consists in offering a correction mechanism to the user, and to implicitly validate the recognition in absence of correction. However, if the user fails to correct a recognition error, the classifier will learn with a wrong label and deteriorate its model. In this paper, we study the use of confusion reject to explicitly solicit the user, to correct or validate the recognized label, when the confidence of the classifier is low. In this way, the system learning focuses on complex data sample, from which it is very beneficial to learn from, with the correct label. Moreover, rejecting data samples with low confidence allow to avoid errors by asking confirmation to the user, and save him from canceling/undoing a wrong command before re-doing the intended one. Our objective is to handle as best as possible the cooperation between the user and the command gesture system to optimize the command gesture use and the classifier training, but without soliciting the user too often.

A sensitive issue is to avoid the "out-of-the-loop performance problem" [START_REF] Kaber | Out-of-the-loop performance problems and the use of intermediate levels of automation for improved control system functioning and safety[END_REF]. This problem is the consequence of system automation where the operator loses direct control. This situation can have harmful consequences like vigilance decrements or complacency. To avoid this problem, [START_REF] Norman | The 'problem' with automation: inappropriate feedback and interaction, not 'over-automation[END_REF] propose to provide feedback to the operator on the automated task and the possibility to take control in case of failure. In this work, automatic system is the evolving recognition engine. Rejection of complex data that are hard to recognize by the classifier allow to inform the user of system difficulties and to explicitly ask him to take control and correct the system. We expected these rejection based interactions to improve user supervision of the recognizer. We will show in the experiments that it's not so easy for all interactive aspects. In fact, if we consider spontaneous corrections from users (not invoked by the system), they decrease because of users over confidence in system capability.

If there is a lot of work in the literature on pattern recognition and handwritten gesture classification, very few approach are evaluated in a real applicative context. We conducted a complete experiment to evaluate our approach in a real context of gesture commands utilization, so that we obtain realistic results from users as well as from the recognizer. We have considered two groups of about thirty users, and both groups had to define and use gesture commands in a testing application. A reference group with spontaneous corrections only, and a second with spontaneous corrections and rejection based user interactions, to study its impact on the on-line training of the classifier. This paper is organized as follows. The Section II presents the architecture of our evolving classifier. We explain in section III the principle of the conflict detection mechanism. Then, we present a realistic user experimentation in Section IV, to analyze the impact of different kinds of user interaction methods and to demonstrate the benefits of the presented approach. Section V concludes and discusses future work.

II. SYSTEM ARCHITECTURE

In this work we use a Fuzzy Inference Systems (FIS) [START_REF] Lughofer | Evolving fuzzy models: incremental learning, interpretability, and stability issues, applications[END_REF], with first order conclusion structure [START_REF] Takagi | Fuzzy identification of systems and its applications to modeling and control[END_REF]. FIS have demonstrated their good performances for incremental classification of changing data flows [START_REF] Angelov | Evolving fuzzy-rule-based classifiers from data streams[END_REF]. Moreover, they can easily be trained on-line -in real time -and have a good behavior with new classes. In this section, we present the architecture of the evolving FIS Evolve [START_REF] Almaksour | Improving premise structure in evolving takagi-sugeno neuro-fuzzy classifiers[END_REF] designed during our past work and that we that we use to recognize our gesture commands.

Fuzzy Inference Systems consist of a set of fuzzy inference rules like the following rule example.

Rule (i) : IF x is close to C (i) (1)
THEN ŷ(i) = (ŷ

(i) 1 ; . . . ; ŷ(i) c ) ⊤ (2)
where x ∈ R n is the feature vector, C (i) the fuzzy prototype associated to the i-th rule and ŷ(i)⊤ ∈ R c the output vector. Rule premises are the fuzzy membership to rule prototypes, which are clusters in the input space. Rule conclusions are fuzzy membership to all classes, that are combined to produce the system output.

A. Premise Structure

Our model uses rotated hyper-elliptical prototypes that are each defined by a center µ (i) ∈ R n and a covariance matrix Σ (i) ∈ R n×n (where n is the number of features).

The activation degree α (i) (x) of each fuzzy prototype is computed using the multivariate normal distribution.

B. Conclusion Structure

In a first order FIS, rule conclusions are linear functions of the input:

ŷ(i)⊤ = (l (i) 1 (x) ; . . . ; l (i) c (x)) (3)
l (i) k (x) = x ⊤ • θ (i) k = θ (i) 0,k + θ (i) 1,k • x 1 + • • • + θ (i) n,k • x n (4)
The i-th rule conclusion can be reformulated as:

ŷ(i)⊤ = x ⊤ • Θ (i) (5)
with Θ (i) ∈ R n×c the matrix of the linear functions coefficients of the i-th rule:

Θ (i) = (θ (i) 1 ; . . . ; θ (i) c ) (6)

C. Inference Process

The inference process consists of three steps:

1) Activation degree is computed for every rule and then normalized as follows:

α (i) (x) = α (i) (x) r k=1 α (k) (x) (7)
where r is the number of rules. 2) Rules outputs are computed using Equation 5and system output is obtained by sum-product inference:

ŷ = r k=1 α (k) (x) • ŷ(k) (8)
3) Predicted class is the one corresponding to the highest output:

class(x) = arg c max k=1 (ŷ k ) (9)

D. Incremental Learning Process

Let x i (i = 1..t) be the i-th data sample, M i the model at time i, and f the learning algorithm. The incremental learning process can be defined as follows:

M i = f (M i-1 , x i ) (10)
whereas a batch learning process would be:

M i = f (x 1 , . . . , x i ) (11)
In our recognizer Evolve [START_REF] Almaksour | Improving premise structure in evolving takagi-sugeno neuro-fuzzy classifiers[END_REF], both rule premises and conclusions are incrementally adapted:

1) Rule prototypes are statistically updated to model the run-time data:

µ (i) t = (t -1) • µ (i) t-1 + x t t (12)
Σ (i) t = (t -1) • Σ (i) t-1 + (x t -µ (i) t-1 )(x t -µ (i) t ) t (13) 2)
Rule conclusions parameters are optimized on the data flow, using the Recursive Least Squares (RLS) algorithm:

Θ (i) t = Θ (i) t-1 + α (i) C (i) t x t (y ⊤ t -x T t Θ (i) t-1 ) (14)
C (i) t = C (i) t-1 - C (i) t-1 x t x ⊤ t C (i) t-1 1
α (i) + x ⊤ t C (i) t-1 x t (15)
New rules, with their associated prototypes and conclusions, are created by the incremental clustering method eClustering [START_REF] Angelov | An approach to online identification of takagi-sugeno fuzzy models[END_REF] when needed.

Figure 1 represents a FIS with first order conclusion structure as a radial basis function (RBF) neural network.

x

C (1) C (r) Π Π Π Π Σ ŷ1 Σ ŷc θ (1) 1 θ (1) c θ (r) 1 θ (r) c . . . . . . . . . . . . first rule ŷ(r) c α (r) x ⊤ • θ (r) 1
Fig. 1. First order FIS as a radial basis function (RBF) neural network

III. CONFUSION BASED USER INTERACTION

In the context of gesture commands, users initialize the system with a few gestures per class (three in our experimentation). To improve gesture command recognition, the classifier learns incrementally during its use. The on-line learning algorithm used to train the classifier during its use is a supervised algorithm. It is hence necessary to label run-time data. Two strategies can be used: an implicit labeling strategy that implicitly validates the recognized label in the absence of correction from the user; and an explicit labeling strategy, that solicits the user to obtain data true label.

The drawback the implicit strategy is that, each time the user doesn't correct the recognized label, the user has to cancel/undo the wrong command that has been executed and then he can re-try to do the intended one. Furthermore, in case of non-corrected error, the classifier is trained with a wrong label, which deteriorates its model. To limit the execution of un-intended commands, and to be sure to learn with correct label, the system can solicit explicitly the user. However, it seems obvious that soliciting the user after each command would be very tedious for the user.

The strategy we use in this paper is to explicitly solicit the user to label the data samples that have a high probability to be mis-classified, and that it is very important to learn from. This kind of sample is difficult to recognize, as a consequence, it's very important to be able to learn from it. In these cases of confusion, the system solicits the user to obtain data true label. In other cases, the recognized label is implicitly validated if the user continues his task in the application. We also offer to users the possibility to explicitly correct the proposed label if he doesn't agree with the system proposal. We use the classifier confidence measure to select the data samples that aren't well described by the classifier model, and from which it will be very beneficial to learn. Considering these difficult samples, the classifier can learn from the gestures that are complex to recognize, and for which it would have probably made a mistake. As a consequence, the rejection strategy has a great influence on the classifier training process. The more data are rejected, the more data are available to train the classifier. Besides, learning from rejected data is very beneficial for the classifier model. Our objective is to improve our classifier recognition performances as much as possible, but without soliciting the user too often.

To detect conflicting classes, we use confusion reject principles [START_REF] Chow | On optimum recognition error and reject tradeoff[END_REF]. Normally confusion reject is done using system output [START_REF] Ishibuchi | Fuzzy classification with reject options by fuzzy if-then rules[END_REF]. However, we try to detect confusion, to evaluate our model quality, at a very early stage of the learning process. As a result, inference rules conclusions are still unstable and are not suitable for confusion detection. Instead, we detect potential confusion on the membership to the different prototypes, which are much more stable at this early stage of the learning process. Even if every prototype participates in the recognition process of every class, each prototype has been created and is mainly associated with a single class. We use that fact to detect confusion when some gesture activates multiple prototypes at the same time.

To detect confusing classes, we define a confidence measure, and an associated confidence threshold. We flag a class as confusing when the confidence of its last gesture is below the threshold (when having learned on all the previous samples).

A. Confidence Measure

We use the Mahalanobis distance to compute the distance of a data sample x to prototype C (i) (defined by a center µ (i) and covariance matrix

Σ (i) ). distance(C (i) , x) = (x -µ (i) ) ⊤ (Σ (i) ) -1 (x -µ (i) ) ⊤ (16)
From this distance, we compute a similarity measure that is smoother than prototype activation.

similarity(C

(i) , x) = 1 1 + distance(C (i) , x) (17)
With this similarity measure, we compute the similarity of a data sample to each prototype and take s f irst and s second as the first and the second highest similarity value. We compute system confidence as:

conf idence = s f irst -s second s f irst (18)
A data sample is then signaled as confusing when its confidence is below a certain threshold.

B. Threshold Selection

The optimization of the threshold below which we estimate gestures as confusing is multi-objective. One wants to maximize both classifier performance and accuracy:

P erf ormance = N Correct /N T otal (19) Accuracy = N Correct /(N Correct + N Errors ) (20)
where N Correct is the number of correctly classified gestures, N Errors is the number of incorrectly classified gestures, and N T otal is the total number of gestures. As the threshold increases, the number of rejected gestures raises and the number classification errors reduces.A high threshold will yield many rejections, which will increase system accuracy, whereas a low threshold will yield only a few rejections, which will increase system performance. There is a trade-off between the classifier performance and accuracy. To solve this trade-off, we must define the cost of an error of classification, and the cost of a rejection. During command definition step, a rejection will make the user change the command gesture (or draw more samples). During the utilization of gesture commands, an error of classification will force the user to correct the system. Our goal when detecting conflicting classes is to reduce classification errors during system use. However, we don't want to signal too many samples as conflicting, which would risk discouraging users from using our system.

The rejection threshold is quite difficult to estimate in our applicative context where we are learning from very few data samples. Moreover, each user chooses his own set of symbols/gestures, which be quite complex to learn by the classifier. The rejection threshold must be automatically estimated for each user and his custom gesture set, and computed in a sufficiently simple and robust manner to yield good results with the few available data.

To estimate the rejection threshold, we chose to initialize our classifier on two of the three initialization samples per class, and to measure the recognition confidence on the third sample. We then compute the mean µ reco and standard deviation σ reco of the correctly recognized data and set the rejection threshold to one standard deviation below the mean: threshold = µ reco -σ reco .

IV. EXPERIMENTATION

This section is dedicated to gesture command experimentation, and to the evaluation of the impact of the strategy of using interactions based on the confusion reject capability of the classifier.

A. Experimental Protocol

We evaluated our system in a real context of gesture commands utilization, so that we obtain realistic results from users as well as from the recognizer. To do so, we designed a testing application: a picture viewer/editor with customizable gesture commands. This application has eighteen basic commands, grouped into six families, to manipulate pictures (like "next", "zoom in", "copy", etc.). We then designed a protocol that simulates a real use of this application to evaluate the impact of user interaction strategies. Our protocol was divided into four phases: an initialization phase to define gestures for each command (see Figure 2a), a first evaluation phase, a utilization phase and a second evaluation phase. During each phase (apart from the initialization phase), users were asked to do several commands one at the time. a) Phase 0: initialization: Users were asked to choose a gesture for each of the eighteen commands of the testing application (see Fig. 2a); and to repeat their gestures a few times to provide some initial training samples for the recognizer.

b) Phase 1: first evaluation phase: During this phase, users were asked to draw each of the eighteen commands once in random order. c) Phase 2: utilization phase: This phase simulates a potential real use of our testing application. A total of twentyfour commands were asked in random order, some commands were asked thrice, some twice, some once and some were not asked. For this utilization phase, a help menu [START_REF] Li | Evaluation of continuous marking menus for learning cursive pen-based commands[END_REF] was available to let users improve their memorization of their gesture commands. d) Phase 3: second evaluation phase: During this phase, users were again asked to draw each of the eighteen commands once in random order.

Each time a gesture is drawn, the recognized command is executed and the command label is displayed at the end of the gesture stroke for three seconds (see Figure 3c). The label allows the user to access a small menu (see Figure 2d) to change the executed command if it isn't the one that is asked. When a gesture is rejected by the classifier, a small menu is displayed with the most probable labels (see Figure 2e), and the user has to select the correct one. Whenever the user corrects the classifier, either when self-correcting by clicking on the recognized label or when a gesture his rejected, he is asked whether the classifier has to learn this correction or not (see Figure 2f). The classifier should learn when the mistake comes from the system, and forget the correction when the user has drawn a wrong gesture (corresponding to another command than the intended one). Whenever the user fails to notice and correct a wrong command, a pop-up (see Figure 2c) is being displayed at the end of the three seconds and ask if it is the user or the recognizer that made the mistake. The user has to re-do the command until it is correctly executed or corrected. All drawn gestures are used to incrementally train the recognizer, including wrong recognition that the user has failed to correct, to be as close as possible of a real utilization of a gesture command system.

A first group of users has done this experimentation without having explicit solicitations by the system based on confusion reject. User could only interact with the system by using spontaneous self-correction (by clicking on the recognized label). The learning process also used the implicit validation to learn from non-corrected samples. Users from this group were not alerted when the recognizer confidence was low. A second group of user has done this experimentation with the new user interaction strategy. The system automatically solicited users when confusion rejects were detected. Users could still do selfcorrection interaction when an error wasn't rejected and the system also learned by implicit validation.

We had 63 persons, from 20 to 57 year-old, participating in our test and everyone of them was used to manipulate computers in daily life. The first group (reference) contains 31 users, while the second group, with rejection based user interactions, contains 32 users.

B. Rejection Performances

Rejection performances are presented in Table I. First, 65.3% of the rejected data would have been mis-classified if not rejected. The rest is rejected because the recognizer confidence is low, even if they are correctly recognized, and it is important to learn from those samples with the correct label. Moreover 79.4% of the classification errors are rejected, which is very good, height mis-classification over ten are avoided.

C. Recognition Performance Improvement

The error and rejection rates are presented Figure 3a and3b. Rejecting data samples with low confidence (12.0% in average) allow to reduce the error rate from 15.1% to 7.06% (53% of relative reduction). We can notice that the rejection rate decreases with time as the classifier discrimination capacities improve, and that the error rate has already converged at the first test. Using rejection based user interactions allow to fasten the learning process of the classifier by improving the classifier learning supervision (progression from Phase 1 to Phase 3).

The performance rates are presented Figure 3c. The performance of the classifier is the rate of correctly labeled data, considering rejected data as non-labeled. There are no major differences between the two groups. The proportion of rejected data in the second group is compensated by the improvement of the classifier recognition performances.

D. User Interaction Improvement

By limiting the number of recognition errors, confusion driven user interactions allow to reduce the number of inputs the user has to draw to correctly execute the desired command (see Figure 3d). In particular, users of group 2 (with reject) draw 17.7% less gestures in average (65.8 instead of 79.8 for the whole experiment) than users of group 1, not using confusion based user interactions.

Consequently, time spent by users (see Figure 3e) is 15.3% lower when using confusion based user interactions (8.96 instead of 10.58 minutes). Even if soliciting the user every time a gesture is rejected by the classifier add several user interactions, it is much quicker for the user to validate/correct the classifier than to cancel a wrong command and do it again.

E. User Attention Deterioration

Figure 3f presents the rate of user corrections when the classifier makes a mistake. It appears clearly in this figure that the group 2 (with reject) suffers from the "user out-of-the-lop syndrome". Users of group 2 only correct 7.72% on average of the classifier remaining mistakes. This illustrates a drawback of our strategy based on an explicit solicitation of the user: this strategy tends to make users over-confident in the system so that they do less and less self-corrections. This point is quite problematic because when a recognition error is not corrected, the classifier is trained with a wrong label which deteriorates its model. Hopefully, using confusion based user interactions reduces the number of recognition errors and limits the classifier model deterioration. For all that, we want to try to address this interesting problem in our future work to optimize the user and system cross-learning process.

V. CONCLUSION

We have presented a new method for increasing the efficiency of personalized gesture commands on pen-based devices. Such gesture commands require an evolving classifier that can learn from very few data samples and learn incrementally. We have explained how our system is able to explicitly solicit the user instead of making a mistake, which save the user from canceling/undoing an un-intended command before re-doing the intended one. Moreover, it allows to train on-line our recognizer Evolve-a first order fuzzy inference systemby explicitly supervising the labeling process with the user.

We have presented a complete and realistic experiment of gesture commands and we have studied the impact of our rejection based interaction method. This new Man-Machine interaction process give rise to a cross-learning situation where users have to learn and memorize command gestures and the classifier has to learn and recognize drawn gestures. In particular, we have shown that using explicit solicitation of the user (based on confusion reject) allows to significantly reduce the error rate and accelerate the on-line learning process. Moreover, rejection based user interactions improve gesture command efficiency by limiting the number of gestures drawn by users and reducing the time needed to complete the experiment.

However, rejection based interactions don't solve completely the "user out-of-the-loop problem". It actually tends to make users over-confident in the system and reduce their vigilance. Future work should address this point to maintain users vigilance and encourage them to spontaneously correct the system when necessary, which is essential to improve the classifier performance as much as possible.

Fig. 2 .

 2 Fig. 2. Testing application screenshots.

System Rejection Rate Distribution

  Error rate, recognition rate, number of inputs, time spent, self-correction rate and lies rate distribution for the two groups on the three phases.

						System Error Rate Distribution			System Performance Rate Distribution
	Rejection Rate	0.0 0.1 0.2 0.3 0.4 0.5	Without Reject With Reject	Error Rate	0.0 0.1 0.2 0.3 0.4 0.5	Without Reject With Reject	Error Rate	0.6 0.8 1.0 0.4	Without Reject With Reject
		Phase 1	Phase 2	Phase 3		Phase 1	Phase 2	Phase 3		Phase 1	Phase 2	Phase 3
		(a) Rejection rate reduction.			(b) Error rate reduction.			(c) Recognition rate improvement.
		User Input Number Distribution			User Time Distribution			User Self Correction Rate Distribution
	Input Number	15 25 35 45	Without Reject With Reject	Time	0 100 300 500	Without Reject With Reject	Self Correction Rate	0.0 0.6 0.2 0.4	Without Reject With Reject
		Phase 1	Phase 2	Phase 3		Phase 1	Phase 2	Phase 3		Phase 1	Phase 2	Phase 3
		(d) Number of inputs reduction.		(e) Time reduction.			(f) Self-correction reduction
	Fig. 3.

TABLE I .

 I REJECTION OVERALL PERFORMANCES.

		Recognized Gestures	Misclassified Gestures	Total
	Non-Rejected Gestures	1750	42	1792
	Rejected Gestures	86	162	248
	Total	1836	204	2040

ACKNOWLEDGMENT

The authors would like to thank Romain LAGNEAU for conducting all the user experiments during his training period within the IntuiDoc team at the IRISA Laboratory.


Abderrahim Lamara
email: abderrahim.lamara@d2t.fr

Patrick Lanusse

Alain Charlet

Dominique Nelson Gruel

Guillaume Colin

Antoine Lesobre

Alain Oustaloup

Yann Chamaillard

D Nelson Gruel

High Dynamic Engine-Dynamometer Identification and Control

Keywords: Identification, multivariable control, CRONE, nonlinear systems, robust control. 

la diffusion de documents scientifiques de niveau recherche, publiés ou non, émanant des établissements d'enseignement et de recherche français ou étrangers, des laboratoires publics ou privés.

INTRODUCTION

The need to reduce pollutant emissions and improve vehicle performances involves the development of new strategies for engine control. At present, the engine performance is checked and validated step by step throughout the whole development process of the engine and its integration in a completed vehicle. Subsequently, the engine is calibrated on-board the vehicle. However, a failure in one step of the development process means a new test process. Today, the automotive industry needs a simpler and shorter process to reduce the development time and hence the cost. To deal with this challenge, a high dynamic test-bed is required, in order to reproduce the road behavior and the gearbox ratio change. The control system should ensure good tracking of speed and torque.

Several aspects of test bed control have tackled in previous studies. In [START_REF] Chauvin | Dynamic periodic observer for a combustion engine test bench[END_REF], the system is firstly modeled by physical equations and then an observer is developed for dynamic estimation of the torque produced by the engine. [START_REF] Priesner | Predictive Control With Active Disturbance Rejection for Elastic Drive Systems[END_REF] presented a model predictive disturbance compensation control concept for an industrial combustion engine test-bed. As the torque control of the vibrating shaft requires a high bandwidth, a short sampling time was used. Based on an approximate model of the test-bed, modified in order to cope with non-modeled dynamics and nonlinearities, Passenbrunner et al. (2011) designed a dynamic control law for the speed and torque control of an internal combustion engine test-bed. Discretetime control design was studied in Shona [START_REF] Laila | Discrete-time control design for setpoint tracking of a combustion engine test bench[END_REF], where a model reference approach was used for the systemcontrol design, to make the controller less sensitive to sampling and to keep sampled-data tracking performance as close as possible to the continuous-time tracking performance. [START_REF] Gruenbacher | Robust Inverse Control for Combustion Engine Test Benches[END_REF] presented a robust inverse control for a combustion engine test-bed. [START_REF] Gruenbacher | Idle Mode Control on a Combustion Engine Test Bench via Internal Mode Control[END_REF] developed an adaptive internal model in order to control a combustion engine testbed in idle mode. In this case the combustion engine is declutched from the power train and hence its only load is the drag (friction) torque. An inverse control torque of hydrodynamic dynamometers for a combustion engine testbed was presented in Passenbrunner et al. (2011), where the dynamometer is modeled by a nonlinear static map combined with linear dynamics, and the model obtained gives the relation between the valve position and the dynamometer torque, using the nonlinear static map as a feed-forward to define the valve position based on the torque demand. Then, a feedback controller is used to compensate uncertainties and disturbance effects. [START_REF] Bunker | Robust Multivariable Control of an Engine-Dynamometer System[END_REF] developed a robust multivariable controller to control a highly coupled Diesel engine-dynamometer system. As the load has a faster dynamic behavior than the combustion engine, the high dynamics of the speed control loop is naturally filtered by the torque control loop. However, the speed is highly affected by the torque variation. A large change in load command would cause engine stall. This paper proposes a faster methodology for test-bed identification and control. For a set of operating points, the dynamics of the system are approximated to a set of linear plants using a fast frequency-domain method. The defined perturbed frequency-domain plant is then used to design a multivariable robust controller.

The test-bed system is described in section 2, and the frequency-domain methodology is presented and then used to approximate the system dynamics to a linear perturbed plant. Section 3 explains how the CRONE Control-System Design (CSD) methodology uses the perturbed plant to design a robust multivariable controller. In the last section, results from experiments are compared and discussed.

SYSTEM IDENTIFICATION

System description

The test-bed used in this paper consists of a simulated engine to be tested and a load, which can be provided by a brake or a dynamometer. It uses a classic configuration (fig. 1) with two real asynchronous machines. The first one simulates a dynamometer. The second machine is associated to a nonlinear model with a variable time constant and variable time-delay, which simulates the behavior of a combustion engine.

The power of the asynchronous machines is about 11 kW, with a max speed of 1500 rpm. The two machines are connected via a transmission and power is supplied by the ACS800 ABB drive. The whole system is piloted by the MORPHEE simulator. MORPHEE is a D2T automation system able to execute automatic cycles, save data during tests and integrate Simulink and AMEsim models to be executed in real time.

Fig. 1: Test-bed configuration

Dynamic combustion engine test-beds are used for many purposes, such as calibration, driving cycles, control development and research. In industry, engineers need to change the engine and the test-bed configuration several times, and then new controllers are required to deal with new challenges. The classical solution is PID tuning around some operating points, but robustness is not guaranteed and such a procedure is very time consuming. In [START_REF] Blumenschein | Easily Adaptable Model of Test Benches for Internal Combustion Engines[END_REF] an adaptive model of the test bench for heavy duty internal combustion engines was presented in order to ease observer design and to compensate for the lack of torque measurement.

Once the engine has been changed, a new test-bed control system is required. The speed can be controlled by the load (dynamometer or brake) and the torque by the engine, the load is highly coupled with the engine through the shaft and any change in the load behavior is observed as a perturbation on the engine side and vice versa. Thus, a MIMO CSD approach seems to be necessary. In the present study, a model of the test-bed was developed based on physical equations and maps. This representative model was used for the development and validation of our proposed methodology. As the load is an electrical machine, its model is approximated to a linear model. The ABB drive is modeled by a simple map combined with a first order filter with timedelay. Nonlinear modeling of the internal combustion engine is unavoidable because of inner nonlinear control loops and various nonlinear mechanical systems (crankshaft, cylinder etc). In this paper, the engine is simply modeled using the same linear model of the load, and an operating point dependent first order filter with a time-constant varying from 0.15s to 1s and a time-delay varying from 0s to 0.2s.

System identification

The frequency-domain CSD approach used in this work requires high fidelity linear dynamic models that approximate the underlying dynamics of the engine. Thus, a frequency domain system identification methodology is used to obtain a linear time-invariant model that approximates the dynamics of the test-bed. A multisine signal is used for input excitation. The use of this broadband signal allows faster frequency domain identification. Based on the multisine frequency response, its spectrum is within the defined band which gives a good approximation of the system dynamics (see [START_REF] Lamara | Decentralized robust control-system for a non-square system, the air-path of a turbocharger Diesel engine[END_REF]. The multisine signal is a linear combination of sinusoids which is given by: where:

N: is the signal harmonics number : is the frequency of harmonic k : is the amplitude of harmonic k : is the initial phase of harmonic k

The amplitude is chosen in such way that the system gives a linear response. In this study the torque variation must be no more than 5% of the maximum torque at the corresponding speed in order to avoid breaking the shaft. The frequency is chosen such that the time-invariant nominal model approximates the most important linear dynamics of the real system. For a good controller design, the frequency must be greater than the desired cut-off frequency or resonant frequency, of the open loop . The excitation signal is chosen with a sampling frequency of 1 kHz and a frequency range from 0.1 Hz to 20 Hz. An automatic cycle is developed, using MORPHEE, to execute the identification process around twenty well-chosen (and arbitrary) operating points. The test-bed studied is a MIMO system with two inputs and two outputs (2x2).

The identification of each element of the transfer matrix consists in exciting only one input, while the second input keeps its mean value. Each element of the frequencyresponse transfer matrix is calculated using the Fast Fourier Transformation (FFT) of the ratio of the cross-correlation between output and input divided by the autocorrelation of input as in [START_REF] Lamara | Decentralized robust control-system for a non-square system, the air-path of a turbocharger Diesel engine[END_REF]. Each input-output transfer is then described: The frequency domain identification provides a nonparametric model. For each element of the transfer matrix, the parameters of a fourth-order transfer function with timedelay were used to obtain a nominal parametric model:

Each element of the nominal transfer matrix is selected using a minimum phase criterion (dark plot on fig. 2). In the next step, the nominal plant and the whole set of calculated frequency-responses are used to design a robust multivariable controller, which maintains performances around a wide set of operating points.

CONTROL METHODOLOGY

The objective of the CRONE control system design is to robustify the closed loop dynamic performance through either a robust damping factor or a robust resonant peak control [START_REF] Oustaloup | CRONE control of resonant plants : application to a flexible transmission[END_REF] based on the unity-feedback configuration (fig. 3). where is the non-zero transfer function and .

Each element of the diagonal open-loop matrix is based on the third generation CRONE single-input singleoutput (SISO) methodology. The principle of this methodology is to optimize the parameters of the nominal SISO open-loop transfer function that includes bandlimited complex fractional order integration over a frequency range . The complex fractional order, a+ib, enables a straight line of any direction to be created in the Nichols chart which is called the generalized template (fig. 4).

In the CRONE SISO methodology, the nominal open-loop transfer function is defined as a multiplication of three transfer functions given by: where is an integer order proportional integrator Order has to be set to manage the accuracy provided by the control system. -is a set of band-limited generalized templates with:

for and

a b  cg M r0 M r max1 (a)
(-180°,0dB) where is the nominal value of the resonant peak. Its minimization is accomplished while respecting closed loop frequency-domain constraints for all plants and for .

+ + + + + + + - ) ( s Y ref ) ( s E ) ( s K ) ( s U ) ( s D u ) ( s D y ) ( s G ) ( s Y ) ( s N ) ( s 
For nxn MIMO systems, the aim of this methodology is to find a diagonal open-loop transfer matrix with n fractional order transfer elements. This transfer matrix is parameterized so as to satisfy the following objectives:

-perfect decoupling for the nominal plant -required nominal stability margins of the closed loops -accuracy specification at low frequency -specifications on the n control efforts at high frequencies.

The resonant peaks taken into account in a cost function based on ( 11) are those of the diagonal elements of the perturbed complementary sensitivity transfer function matrix T. The controller elements are obtained from relations ( 5) and ( 7):

As β jj (s) are fractional order transfer functions, the rational transfer functions K Rij (s) are obtained by identifying the ideal frequency responses K ij (j) by low-order transfer functions:

      s A s B s K ij  R (13)
where B(s) and A(s) are polynomials of specified integer degrees n B and n A . All the frequency-domain systemidentification techniques can be used (for instance [START_REF] Oustaloup | The CRONE toolbox for Matlab[END_REF][START_REF] Oustaloup | Frequency synthesis of filter using the functions Viète's roots[END_REF]. Whatever the complexity of the control problem, it is easy to find satisfactory values of n B and n A without a decrease in performances.

Since

is a full matrix transfer function, from (5) the controller will be a full MIMO controller (fig. 5). All the elements of the transfer matrix will be taken into account for open-loop optimization. The decoupling and stabilizing controller K exists if and only if the following hypotheses are verified: exists, (

where and indicate the positive real part zero and pole sets.

Even if the closed-loop perturbed transfer matrices T(s) and S(s) are not diagonal, each diagonal element T ii (s) and S ii (s) can be interpreted as a closed-loop transfer function resulting

- ( (18)
) 19
where G is the nominal or perturbed plant, and while respecting the frequency-domain inequalities below for and :

(20) (21) (22) (23) (24) with (25) (26)

EXPERIMENTAL RESULTS

The association of the engine with the dynamometer makes the system highly coupled. It is possible to design two controllers to control the speed and the torque separately. In the proposed methodology, the CRONE full-MIMO controller controls the speed and the torque simultaneously.

In order to evaluate the controller performances, a testperformance cycle was developed in MORPHEE (fig. 8 and9). The user indicates the maximum and the idle speeds, and then set-points are generated automatically by MORPHEE.

Two controllers were tested on the real system, and the controller performances were compared using the testperformance cycle developed. The first controller consists of two PIDs tuned by trial and error using the experimental system. As is customary in industry, the torque control loop is open and the speed PID controller is tuned. Once the speed PID has been tuned, the torque loop is then closed and the torque PID controller is tuned.

The second controller is a CRONE MIMO controller. In the MIMO approach all the elements of the nominal transfer matrix are used for the open-loop optimization. Fig. 6 shows the open-loop optimization. A bandwidth of 8 rad/s was chosen to guarantee fast tracking of the speed set-point. As the perturbed frequency responses are noisy, the resonant peak can be considered to be about 2 dB (the frequency response inside the low stability area is considered as noise) which makes the controller robust around the identified operating points. For the test-performance cycle, the speed step-response from 440 rpm to 800rpm and then from 800 rpm to 1160 rpm is shown in fig. 8. From the comparison between the PID and the CRONE controllers, speed set-points tracking, it can be seen that the CRONE overshoot is less than the PID overshoot, but that the settling times are very close, despite the fact that the PID rise time is less than the CRONE rise time. Concerning the control efforts, the CRONE full MIMO effort is less than that of the PID controller. After the speed step, the CRONE full MIMO tries to reach the setpoint by acting simultaneously on the current and the throttle, whereas the PID uses only the current effort to reach the speed setpoint. Fig. 9 shows the torque step-response from 28 Nm to 3.5 Nm, from 3.5 Nm to 28 Nm and from 28 Nm to 56 Nm. It reveals that for this operating point, the torque responses are extremely close. For both outputs, the CRONE MIMO controller ensures the best rejection of coupling phenomena.

The torque response shown in fig. 10 presents a robustness problem observed for a torque step from 56 Nm to 28 Nm, but now for a speed of 440 rpm. The instability of the PID responses can be attributed to the fact that the operating point chosen for the PID tuning was very different from the one tested here. For the CRONE full MIMO controller, robustness is guaranteed around all the operating points.

CONCLUSION

A full methodology is presented in this paper for multivariable system-identification and robust controller design. The identification problem is discussed for the proposed nonlinear engine-dynamometer system. After data processing, a nominal plant is defined in order to approximate the most important dynamics of the highly coupled time-varying system, all the calculated frequency responses being taken into account as the plant perturbation model. The CRONE MIMO methodology demonstrates how the robust controller is designed using the defined perturbed plant. The CRONE full MIMO controller designed ensures good set-points tracking and good robustness. The results show the relevance of the proposed methodology. This methodology will be used to design a controller for a high dynamic engine-dynamometer system with a Diesel engine.

GG

  11 : from current input (%) to speed sensor (rpm) G 12 : from throttle (%) to speed sensor (rpm) G 21 : from current input (%) to torque sensor (N.m) 22 : from throttle (%) to torque sensor (N.m)

Fig. 3 :

 3 Fig. 3: Unity-feedback configuration for CRONE approach and are disturbances on input and output. is measurement noise.is the error and is the control effort. Fractional differentiation is used to define the nominal and diagonal open-loop transfer function of square systems (nxn):

Fig. 2 :

 2 Fig. 2: Bode diagram of the real system around twenty operating points and the defined nominal plant (dark)

Fig. 4 :

 4 Fig. 4: (a) any generalized template, (b) optimal template

  from a SISO open-loop transfer function  ii (s) called equivalent open-loop transfer function: (16) Taking into account this equivalent perturbed open-loop transfer function, the optimization of all diagonal elements is achieved by minimizing the robustness cost function:

Fig. 5 :

 5 Fig. 5: Full MIMO control for the 2x2 test bed square system

Fig. 6 :

 6 Fig. 6: open-loop optimization and equivalent openloop

Fig. 7 :

 7 Fig. 7: open-loop optimization and equivalent openloop

Fig. 8 :

 8 Fig. 8: Speed set-points tracking and current control effort

Fig. 10 :

 10 Fig. 10: Robustness problem during a torque step