Memoire Online - Prédiction de défauts logiciel utilisant des techniques d'apprentissage automatique

			PC1= 0.913
		LR	JW1=0.788 MC1=0.973 M=0.664 PC1=0.894
		RF	JW1=0.778 MC1=0.977 M=0.688 PC1=0.909
		SVM	JW1= 0.790 MC1= 0.977 M= 0.680 PC1= 0.913
	PROMISE Dataset	DBN	XALAN V2.6= 0.536 ANT V 1.7= 0.77 JEDIT V4.0= 0.755 LOG4J V1.0= 0.748
		LR	XALAN V2.6= 0.733 ANT V 1.7= 0.820 JEDIT V4.0= 0.755 LOG4J V1.0= 0.733
		RF	XALAN V2.6= 0.743 ANT V 1.7= 0.815 JEDIT V4.0= 0.780 LOG4J V1.0= 0.759
		SVM	XALAN V2.6= 0.731 ANT V 1.7= 0.813 JEDIT V4.0= 0.768 LOG4J V1.0= 0.756
	AEEEM Dataset	DBN	LC=0.907 JDT= 0.793 PDE=0.86 ML= 0.868
		LR	LC= 0.841 JDT= 0.856 PDE= 0.856 ML= 0.861
		RF	LC= 0.917 JDT= 0.840 PDE= 0.864 ML= 0.865
		SVM	LC= 0.907 JDT= 0.849 PDE= 0.861 ML= 0.869
	RELINK Dataset	DBN	Apache= 0.448 Safe= 0.607 Zxing= 0.704
		LR	Apache= 0.624 Safe= 0.732 Zxing= 0.679
		RF	Apache= 0.691 Safe= 0.705 Zxing= 0.679
		SVM	Apache= 0.660 Safe= 0.571 Zxing= 0.692
[13]		SVM	AR1= 0.81 AR3= 0.625

SOFTLAB dataset		AR5= 0.833
SOFTLAB dataset	DT	AR1= 0.901
		AR3= 0.906
		AR5= 0.778
	BPNN	AR1= 0.918
		AR3= 0.906
		AR5= 0.702
	RF	AR1= 0.946
		AR3= 0.947
		AR5= 0.818

Les techniques d'apprentissage automatique se sont avérés être des techniques de pointe pour des problèmes de prédiction des défauts logiciels. Cela permet au gestionnaire de logiciel d'allouer efficacement les ressources du projet vers les modules qui nécessitent plus d'efforts. Cela permettra éventuellement aux développeurs de corriger les bogues avant de livrer le produit logiciel aux utilisateurs finaux.

Dans ce chapitre d'état de l'art on essayer d'exposer les processus de prédiction des défauts logiciels. Nous avons aussi présenté la question de recherches qui ont posé lors de la réalisation de notre approche et nous avons clôturé le chapitre par des travaux proposés dans la littérature utilisant des différentes techniques d'apprentissage automatique dans la tâche de prédiction.

L'apprentissage supervisé est une classe technique d'apprentissage automatique (le plus fréquemment utilisé) où l'on cherche à produire automatiquement des règles à partir d'une base de données d'apprentissage contenant des échantillons déjà étiquetés [16].

En d'autres termes, l'apprentissage supervisé vise à estimer une fonction f: x - y telle que la sortie d'un objet de test xi (qui n'a pas été traité pendant la phase d'apprentissage) peut être prédit avec une grande précision. L'apprentissage supervisé peut être formulé de la manière suivante :

Une instance xi signifie un objet spécifique, elle est typiquement représentée par un vecteur de caractéristique de dimension D, X = {xi}i=1

?? représentent les étiquettes de classe de l'i^émeobjet. K est le nombre de variables

de sortie que peut avoir un objet d'entrée (Si Y est une valeur discrète, on parle de classification, et Si Y est une valeur continue, on parle de régression) [10].

Dans l'apprentissage supervisé, un ensemble d'exemples, « l'ensemble d'apprentissage », est soumis à l'entrée du système pendant la phase d'apprentissage. Par la suite, chaque entrée est étiquetée avec une valeur de sortie désirée [17]. La figure 2.1 illustre le processus d'apprentissage supervisé.

2.2. Les Techniques D'apprentissage supervisé 2.2.1. Machine à Vecteur de Support

Machine à Vecteur de Support (en anglais : Support Vector Machine (SVM)) est un algorithme d'apprentissage supervisé, le principe derrière cet algorithme est d'utiliser une ligne pour séparer les données en plusieurs catégories, de sorte que la distance entre les différents types de données et la frontière qui les sépare soit maximale [18]. Cette distance est également appelée «marge» définie comme la distance entre le point le plus proche et l'hyperplan de séparation.

Les SVM linéaires cherchent le séparateur (l'hyperplan de séparation) qui maximise la marge et on appelle cela « séparateur à vaste marge » [18].

Le vecteur de support est la donnée la plus proche de la limite. Si ???? est un vecteur de support et H = { w . x + b = 0}, alors la marge est donnée par l'équation (3) :

Pour que le classifieur SVM puisse trouver cette frontière, il est nécessaire de lui donner des données d'apprentissage. En l'occurrence, on donne au classifieur SVM un ensemble de points. A partir de ces données, le classifieur SVM estimera la position la plus raisonnable de la frontière [18].

Une fois la phase d'apprentissage est terminée, le classifieur SVM a ainsi trouvé, à partir de données d'apprentissage, l'emplacement supposé de la frontière. En quelque sorte, il a « appris» l'emplacement de la frontière grâce aux données d'apprentissage et il est maintenant capable de prédire à quelle catégorie appartient une entrée qu'il n'avait jamais vue avant, et sans intervention humaine [18][19].

Un réseau de neurones artificiels (en anglais : Artificial Neural Network (ANN)) est un modèle de calcul pour effectuer des tâches telles que la prédiction, la classification, la prise de décision, etc [20]. Comme l'indique la partie «neurale» de son nom, c'est un système inspiré du cerveau conçus pour imiter la façon dont nous, les humains, apprenons.

Les réseaux de neurones artificiels ont une fonction d'auto-apprentissage, et lorsque plus de données sont obtenues, ils peuvent produire de meilleurs résultats. Un réseau de neurones artificiels est un ensemble de plusieurs perceptrons / neurones sur chaque couche. Le classifieur ANN est également appelé réseau de neurones à action directe, car l'entrée n'est traitée que dans un sens direct [20].

Un réseau neuronal se compose de trois couches. La première couche est la couche d'entrée. Elle contient des neurones d'entrée qui envoient des informations à la couche cachée. Cette dernière effectue les calculs sur les données d'entrée et transfère la sortie vers la couche de sortie. Elle comprend le poids, la fonction d'activation et la fonction de coût [21]. L'architecture des réseaux de neurones artificiels est présentée dans la Figure ci-dessous :

Figure 2.3. Réseaux de neurones artificiels.[21] 2.2.3. Les forêts d'arbres décisionnels

Les forêts d'arbres décisionnels (en anglais : Random forest (RF)) est un algorithme d'ensemble ayant un ensemble différent d'hyperparamètres et entraînés sur différents

sous-ensembles de données, largement utilisé dans la régression, la classification et d'autres tâches. L'algorithme crée un certain nombre d'arbres de décision et les combine en un seul modèle. Pour les problèmes de classification, la prédiction finale faite par l'algorithme est basée sur un vote majoritaire de tous les arbres où chaque arbre fait une prédiction de classe [23].

Une sélection aléatoire de caractéristiques est utilisée lors de la croissance des arbres et de la division de chaque noeud. Dans l'algorithme standard, l'ensemble de caractéristiques est vérifié à chaque noeud pour trouver la caractéristique la plus importante à diviser. En revanche, pour diviser chaque noeud dans la forêt, un sous-ensemble aléatoire de m <M caractéristiques est considéré, où M est le nombre total d'entités [22]. La meilleure façon de déterminer combien d'arbres sont nécessaires est de comparer les prédictions faites par une forêt aux prédictions faites par un sous-ensemble d'une forêt. Lorsque les sous-ensembles fonctionnent ainsi que la forêt complète, cela indique qu'il y a suffisamment d'arbres [23].

La figure 2.4 montre comment un exemple est classé en utilisant n arbres où la prédiction finale est faite en prenant un vote de tous les n arbres.

L'apprentissage non supervisé est une classe technique d'apprentissage automatique où les exemples d'apprentissage fournis par le système ne sont pas étiquetés avec la classe

d'appartenance. Il s'agit d'extraire des classes ou groupes d'individus présentant des caractéristiques communes. L'apprentissage non supervisé est un problème plus difficile que l'apprentissage supervisé en raison de l'absence d'un objectif bien défini indépendant de l'utilisateur. [17]

?? , et une mesure de similarité entre des paires de vecteur k : ?? × ?? ? R. Le but de l'apprentissage non supervisé est de partitionner l'ensemble de telle sorte que les objets au sein de chaque groupe soient plus semblables les uns aux autres que les objets entre les groupes [17]. La figure 2.5 représente le déroulement du processus d'apprentissage non supervisé.

3.2. Les techniques d'apprentissage non supervisé 3.2.1. L'algorithme K-moyennes

L'algorithme K-moyennes (en anglais : K-means) est un algorithme de clustering qui tente de regrouper les observations en différents clusters. Plus précisément, le but de cet algorithme est de minimiser les différences au sein des clusters et de maximiser les différences entre les clusters [24].

L'entrée de cet algorithme est composée du nombre de clusters et l'ensemble de données non étiqueté. C'est un outil de partitionnement des données non-hiérarchique qui permet de répartir les données en clusters homogènes [24]. Pour cela, il cherche à minimiser la variance interclasse :

Pour effectuer un regroupement, la première étape consiste à spécifier le nombre de clusters (K). Ensuite, l'algorithme K-moyennes attribuera chaque observation à exactement l'un des K-clusters. C'est un problème mathématique assez simple et intuitif

L'algorithme d'espérance-maximisation (en anglais : Expectation Maximization (EM)) est une classe d'algorithmes qui permettent principalement de trouver le maximum de vraisemblance des paramètres de modèles probabilistes lorsque le modèle dépend de variables latentes non observables dans le cadre des problèmes liés aux données incomplètes (consiste à associer à un problème aux données incomplètes) [28]. L'algorithme EM se déroule en deux étapes :

- Étape d'Expectation : Dans cette phase l'algorithme peut estimer des données inconnues en considérant et en comprenant les données observées et les valeurs des paramètres déterminées lors de l'itération précédente [27].

Étape de Maximisation : Dans cette phase l'algorithme maximise la vraisemblance en utilisant l'estimation des données inconnues de l'étape précédente et met à jour les valeurs des paramètres pour l'itération suivante [27].

L'apprentissage profond est une branche récente de l'apprentissage automatique, dans laquelle les machines peuvent apprendre par elles-mêmes. L'apprentissage profond utilise l'apprentissage supervisé une technique qui consiste à fournir à un programme des milliers de données étiquetées, qu'il devra apprendre à reconnaître (voir section 2.2). L'apprentissage en profondeur est basé sur des déclarations similaires qui imitent les méthodes d'apprentissage que les humains utilisent pour acquérir certains types de connaissances, tandis que les modèles d'apprentissage en profondeur sont basés sur des réseaux de neurones artificiels (voir section 2.2).[29]

L'apprentissage profond a été appliqué dans plusieurs domaines et a prouvé son efficacité notamment dans : domaine médical où certains programmes qui utilisent l'apprentissage profond sont parfois plus fiable que l'analyse humaine [31], domaine scientifique [32], domaine de l'automobile [33], de l'industrie [34], le domaine militaire (45) ...etc. [30]

La différence entre les techniques traditionnelles de l'apprentissage automatique et l'apprentissage profond est que dans les techniques traditionnelles l'extraction des caractéristiques pertinentes se fait manuellement (en utilisant des techniques d'extraction des caractéristiques), contrairement à l'apprentissage profond, les données brutes font l'entrée du réseau et l'extraction des caractéristiques se fait d'une manière automatique à l'intérieur du réseau.

L'idée de base des réseaux de neurones convolutifs appelé aussi ConvNets (en anglais : Convolutional Neural Network (CNN)) s'inspire d'un concept de biologie appelé champ réceptif. Les champs réceptifs sont une caractéristique du cortex visuel animal. Ils agissent en tant que détecteurs sensibles à certains types de stimulus, par exemple, les bords. Les neurones de cette zone du cerveau sont arrangés de manière à ce qu'ils

correspondent à des zones qui se chevauchent lors du pavage du champ. Cette fonction biologique peut être approchée par ordinateur en utilisant l'opération convolutif [35].

Un réseau de neurone convolutif est une forme spéciale de réseaux de neurones convolutif conçue pour traiter des données avec plusieurs tableaux et topologies en forme de grille. Ce classifieur Convolutif a connu un énorme succès et il a de large applications pratiques, y compris la reconnaissance vocale [37], la classification d'images [38] le traitement du langage naturel [39] et autres domaines. Désignés par l'acronyme CNN, il comporte deux parties bien distinctes : (i) une partie convolutive du modèle, (ii) une partie classification du modèle qui correspond à un modèle MLP (Multi Layers Perceptron). Récemment, il a été découvert que le classifieur CNN possède également d'excellentes capacités d'analyse de séquences de données [36]. En général, CNN se compose de couches convolutives et de regroupements (sous-échantillonnage) et suivies d'une ou plusieurs couches entièrement connectées, ces couches empilées les unes sur les autres pour former un modèle profond. Les couches convolutives apprennent les représentations des entités de leur entrée et les neurones sont organisés en une carte de caractéristiques (feature map) [40].

CNN a montré le potentiel pour résoudre les problèmes dans plusieurs domaines notamment dans le domaine du génie logiciel [41]. Un réseau CNN présente deux caractéristiques clés qui sont une connectivité clairsemée et des poids partagés et ses paramètres sont appris à l'aide de la rétro-propagation. Le réseau se distingue de l'architecture traditionnelle avec deux aspects : la connectivité locale et le partage des paramètres. Les cellules de la couche cachée du CNN ne sont connectées qu'à un petit nombre de cellules, correspondant à la zone locale de l'espace. Ce processus réduit le nombre de paramètres dans le réseau, la charge mémoire et le risque de sur-apprentissage. De plus, CNN réduit également le nombre de paramètres d'apprentissage en partageant la même fonction de base (c'est-à-dire le filtre de convolution) à différentes positions de l'image [36].

Un réseau CNN typique a une couche d'entrée et une couche de sortie, ainsi que plusieurs couches cachées. Les couches cachées d'un CNN se composent généralement d'une série de couches convolutives. ReLU est une fonction d'activation typique, qui est

normalement suivie par des opérations supplémentaires telles que la mise en commun des couches, des couches entièrement connectées et des couches de normalisation. La rétro-propagation est utilisée pour la distribution des erreurs et l'ajustement du poids. La figure 2.6 illustre la structure de CNN. [42]

L'architecture du CNN se compose d'un ensemble de couches de traitement indépendantes, Chaque couche reçoit des données d'entrées et produit des nouvelles données en sortie. Ici, nous discuterons en détail le fonctionnement des différentes couches du CNN.

La couche de convolution est le bloc de construction de base d'un CNN. Son but est de repérer la présence d'un ensemble de caractéristiques (éléments ou patterns) dans les images reçues en entrée. La convolution est une opération mathématique pour fusionner deux ensembles d'informations, appliquée sur les données d'entrée à l'aide d'un filtre de convolution pour produire une carte de caractéristiques. Le principe est de faire "glisser" une fenêtre représentant les caractéristiques sur l'image, et de calculer le produit de convolution entre la caractéristique et chaque portion de l'image balayée. Une caractéristique est alors vue comme un filtre : les deux termes sont équivalents dans ce contexte[44][45].

On distingue trois hyper-paramètres utilisés pour déterminer le volume de la couche de convolution :

- le pas qui contrôle le chevauchement des champs récepteurs. Plus le pas est petit,
plus les champs récepteurs se chevauchent et plus le volume de sortie sera grand[5] .

- la marge, parfois, il est commode de mettre des zéros à la frontière du volume
d'entrée. La taille de ce zero-padding est le troisième hyper-paramètre. Cette marge permet de contrôler la dimension spatiale du volume de sortie. En particulier, il est parfois souhaitable de conserver la même surface que celle du volume d'entrée [5].

Dans une couche de convolution un produit de convolution est appliqué qui consiste à multiplier chaque pixel du filtre par la valeur du pixel correspondant dans l'image. Ensuite, les résultats sont additionnés et divisés par le nombre total des pixels du filtre. Ce produit de convolution sert à extraire des caractères spécifiques dans l'image traitée [35]. L'opération de convolution est illustrée dans la figure ci-dessous :

Contrairement aux méthodes traditionnelles, les caractéristiques ne sont pas prédéfinies selon une forme spécifique, mais sont apprises par le réseau lors de la phase d'apprentissage. Le noyau du filtre fait référence au poids de la couche convolutive. Ils sont initialisés puis mis à jour par rétropropagation du gradient. C'est là que réside l'avantage des réseaux de neurones convolutifs : ils peuvent déterminer les éléments discriminants de l'entrée en s'adaptant à la question posée. Par exemple, si le problème est de faire la distinction entre les chats et les chiens, des caractéristiques définies automatiquement peuvent décrire la forme des oreilles ou des pattes [45].

Après l'opération de convolution, un regroupement est effectué généralement pour réduire la dimensionnalité (pooling). Cette couche située entre deux couches convolutives, elle reçoit en entrée plusieurs feature maps, et applique une opération de maximum locale (Max Pooling) à chacune d'entre elles l'opération de pooling. Pour cela, elle divise une carte de caractéristiques en petites fenêtres de même taille qui peuvent se recouvrir. En fait, seule la valeur maximale est conservée dans chaque fenêtre. Par conséquent, la couche de pooling produit donc en sortie une carte de caractéristiques plus petite, ce qui permet de réduire le nombre des paramètres et de calculs dans le réseau et de contrôler également le sur-apprentissage (overfitting) [45]. On distingue principalement trois types de pooling :

- Le max pooling : C'est le type le plus utilisé car il est rapide à calculer et permet

de simplifier efficacement l'image, qui revient à prendre la valeur maximale de la sélection. [46].

- Le mean pooling (ou average pooling), Soit la moyenne des pixels sélectionnés
: on calcule la somme de toutes les valeurs puis on divise par le nombre de valeurs. Nous avons donc obtenu une valeur intermédiaire pour représenter ce lot de pixels. La mise en commun moyenne utilise uniquement la réduction de dimensionnalité comme mécanisme de suppression du bruit [46].

- Le sum pooling est la moyenne sans avoir divisé par le nombre de valeurs (on ne
calcule que leur somme) [46].

D'un autre côté, la différence entre le pooling max et le pooling moyen est plus évidente (et importante) : en termes de nature, le pooling max aura tendance à retenir les caractéristiques les plus importantes et les plus simples dans la sélection des pixels. Au contraire, le pool moyen est une valeur moyenne, et seules les caractéristiques moins significatives apparaîtront [45].

ReLU (abréviation de Unité Linéaire Rectifiée) désigne la fonction réelle non-linéaire. ReLU remplace toutes les valeurs négatives sur la carte des caractéristiques par des zéros comme le montre la figure (2.10) ci-dessous. Donc l'objectif de ReLU est d'introduire la non-linéarité dans notre ConvNet, la plupart des données du monde réel apprises par ConvNet sont non linéaires (la convolution est une opération linéaire), la matrice est multipliée et ajoutée élément par élément, et les fonctions non linéaires (telles que ReLU) sont introduites pour résoudre des problèmes non linéaires[47][49].

La fonction d'activation ReLU est une fonction dite « rectifier » très utilisée en Deep Learning [46]. Définie par??(??) = max (0, ??). Dans les réseaux de neurones convolutifs, il est souvent appliqué à la sortie d'une couche de convolution pour les raisons suivantes :

Dernière étape de la partie «extraction des informations», flatening consiste à convertir les données en un tableau à une dimension pour les saisir dans la couche suivante. Nous aplatissons la sortie des couches convolutives pour créer un seul vecteur de caractéristiques long [49].

La couche entièrement connectée (en anglais : Fully connected (FC)) reçoit donc un vecteur de nombres en entrée et modifie ces valeurs pour produire un nouveau vecteur et renvoie des probabilités pour chaque classe de prédiction. Les couches FC sont typiquement présentes à la fin des architectures des CNN et chaque noeud de la couche est connecté avec tous les neurones de la couche précédente [45].

Le réseau de neurones convolutif apprend les valeurs des poids de la même manière qu'il apprend les filtres de la couche de convolution : lors de phase d'apprentissage, par rétro-propagation du gradient.

La couche FC détermine la relation entre la position de l'entité dans l'image et la classe. En fait, la table d'entrée est le résultat de la couche précédente, qui correspond à la carte d'activation d'une caractéristique donnée : des valeurs élevées indiquent l'emplacement de la caractéristique dans l'image (plus ou moins selon le regroupement). [45]

La couche de perte (LOSS) est la dernière couche dans le réseau. Elle spécifie comment l'apprentissage du réseau pénalise l'écart entre le signal prévu et le signal réel. La sortie du neurone de la couche entièrement connectée est convertie en probabilité par la fonction d'activation "softmax". La perte softmax permettra de générer un score de probabilité normalisé, la somme des probabilités sera égale à 100%, soit 1. [50]

Essentiellement, tout paramètre que vous pouvez initialiser (avant d'entraîner le modèle de réseau neuronal) peut être considéré comme un hyperparamètre

Au cours de chaque cas de test, différents hyperparamètres seront modifiés pour vérifier leur effet sur la précision et l'ajustement des hyperparamètres dépend généralement de l'expérience que des connaissances théoriques. Il n'y a pas de règles stables pour choisir les bons paramètres, et le choix dépend de la taille de l'ensemble de données d'entraînement et du type. Donc, Le réglage des hyperparamètres est important pour choisir les paramètres corrects afin d'obtenir les résultats souhaités. Le choix des paramètres corrects est essentiel, mais considéré comme une partie complexe de la formation en réseau. [35]

Dans les réseaux de neurones, il existe des couches pour effectuer des calculs. Chaque couche est constituée d'un nombre spécifique de neurones. Ainsi, le nombre de filtres dans CNN est le nombre de neurones présents dans un réseau neuronal. Chaque neurone effectue une convolution différente Le nombre de filtres est le nombre de neurones. Afin de rendre les calculs de chaque couche égaux, le produit de la quantité de caractéristiques et du nombre de pixels traités est généralement sélectionné pour être approximativement constant entre les couches. [35]

La forme du filtre est très variable dans la littérature. Ils sont généralement sélectionnés en fonction de l'ensemble de données. Les meilleurs résultats pour les images (28x28) se situent généralement à moins de 5x5 du première couche, tandis que les ensembles de données d'images naturelles (généralement des centaines de pixels dans chaque dimension) peuvent utiliser un filtre de première couche plus grand de 12 x 12 ou même 15 x 15. Par conséquent, le défi est de trouver le bon niveau de granularité pour créer des abstractions à la bonne échelle et s'adapter à chaque situation. [35]

La valeur typique est 2 × 2. Un volume d'entrée très important peut justifier l'utilisation d'un pooling 4×4 dans la première couche. Cependant, le choix d'une forme plus grande

réduira considérablement la taille du signal et peut entraîner la perte d'une trop grande quantité d'informations. [35]

L'apprentissage automatique est devenu l'outil de choix pour de nombreuses applications, regroupe les techniques permettant à une machine d'adapter et d'améliorer ses performances par l'expérience. Ces dernières années, le domaine d'intelligence artificiel a connu un grand renouveau avec les techniques de l'apprentissage profond, inspirées des réseaux de neurones du cerveau qui a particulièrement fait parler de lui.

L'apprentissage profond et plus précisément les réseaux de neurones convolutifs ont obtenus des performances remarquables dans divers domaines. C'est pour ce succès que nous avons choisis cet algorithme afin de l'appliqué dans la prédiction des défauts logiciels.

Chapitre 03 : SFP-NN : Apprentissage profond pour la prédiction des défauts logiciels | 38

Chapitre 03 : SFP-NN : Apprentissage profond pour la prédiction des défauts logiciels | 39

Les trois éléments importants du processus de prédiction des défauts logiciels sont : jeu de données sur les défauts logiciels, techniques de prédiction des défauts logiciels et mesures d'évaluation des performances.

Chapitre 03 : SFP-NN : Apprentissage profond pour la prédiction des défauts logiciels | 40

Dans notre étude, nous proposons une approche basée sur une technique avancée de l'apprentissage automatique qui est le deep learning. Nous avons opté pour l'algorithme d'apprentissage profond qui est le réseau de neurones convolutifs (CNN) qui a prouvé son efficacité dans plusieurs domaines. La figure 3.1 ci-dessous montre le déroulement du SFP-NN proposé, nous avons commencé avec une collection de bases de données sélectionnés avec divers pourcentages de pannes. Une étape de prétraitement est achevée afin de normaliser les données ainsi que les préparer pour l'étape suivante. Par la suite, la collection des bases de données est partitionnée en un ensemble d'apprentissage et un ensemble de test. Le classifieur CNN commence la phase d'apprentissage en initialisant les paramètres (couches, fonctions d'activation...etc.) afin de créer un bon modèle de classification. Enfin, une phase de test est appliquée afin de mesurer les performances du modèle créé

Dans cette étude, nous utilisons plusieurs ensembles de données de défauts logiciels de différentes entreprises comme données sources. Les ensembles de données SOFTLAB et

Chapitre 03 : SFP-NN : Apprentissage profond pour la prédiction des défauts logiciels | 41

NASA ont été collectés respectivement auprès d'une société de logiciels turque et de nombreux sous-traitants du référentiel MDP (en anglais : Metrics Data Program) de la NASA [60], c'est une base de données qui stocke les données relatives aux problèmes, aux produits et aux mesures. Pour l'ensemble de données SOFTLAB, nous utilisons cinq projets AR1, AR3, AR4 , AR5 et AR6 qui sont des logiciels de contrôleur intégrés dans le référentiel PROMISE. Nous utilisons sept projets de la NASA : KC1, K, MC1, M, CM1, PC1, P, PC3 et PC4, qui ont les mêmes métriques dans le référentiel PROMISE [51]. Les auteurs dans ont constaté que l'ensemble de données de la NASA sont incohérents et contient des cas de conflit. Par conséquent, nous utilisons une phase de prétraitement des ensembles de données de la NASA pour la préparer aux étapes suivantes. [52]

Il existe 28 métriques communes entre la NASA et SOFTLAB. Ces métriques sont les métriques cyclomatiques de Halstead et McCabe, mais la NASA a des métriques de complexité supplémentaires telles que le nombre de paramètres et le pourcentage de commentaires.

Les mesures de complexité et de taille comprennent des mesures bien connues, telles que Halstead, McCabe, le nombre de lignes, le nombre d'opérateurs / opérandes et les mesures de nombre de succursales. Les métriques Halstead sont sensibles à la taille du programme et aident à calculer l'effort de programmation en mois. Les métriques McCabe mesure la complexité du code (flux de contrôle) et aident à identifier le code vulnérable. Les différentes métriques de McCabe comprennent la complexité cyclométrique, la complexité essentielle, la complexité de la conception et les lignes de code [2]

Les métriques cibles (variables dépendantes) sont le «nombre d'erreurs» et les «défauts». «Nombre d'erreurs» fait référence au nombre d'erreurs de module associées à l'ensemble correspondant de métriques du logiciel prédicteur, tandis que la métrique «Défaut» indique si le module est sujet aux pannes ou sans défauts. [2]

Chapitre 03 : SFP-NN : Apprentissage profond pour la prédiction des défauts logiciels | 42

*Base de données*	*Attributs*	*Instances*	*Langage*	*Défectueux%*
KC1	21	2107	C++	15.45%
K	40	458	C++	20.50%
MC1	39	9466	C &C++	0.7%
M	39	161	C++	32%
CM1	40	505	C	9.83%
PC1	40	1107	C	6.94%
P	40	5589	C	0.4%
PC3	40	1563	C	10%
PC4	40	1458	C	12%
AR1	31	121	C	7.44%
AR3	31	63	C	12.7%
AR4	31	107	C	18.69%
AR5	31	36	C	22.22%
AR6	31	101	C	14.85%

Kc1	C++	Gestion du stockage pour la réception et le traitement des données au sol
Kc2	C++	Traitement des données scientifiques
mc1	C++	__
mc2	C++	Système de guidage vidéo
cm1	C	Un instrument de vaisseau spatial de la NASA
pc1	C	Un système de satellites en orbite terrestre.
pc2	C	Simulateur dynamique pour systèmes de contrôle d'altitude
pc3	C	Logiciel de vol pour satellite en orbite terrestre
pc4	C	Logiciel de vol pour satellite en orbite terrestre
Ar1	C	Contrôleur embarqué
Ar3	C	Contrôleur embarqué

Chapitre 03 : SFP-NN : Apprentissage profond pour la prédiction des défauts logiciels | 43

Les métriques logicielles fournissent des informations pour la prédiction des défauts. À l'heure actuelle, il existe de nombreuses mesures pour évaluer risques logiciels. Et parmi elles, trois catégories contiennent les métriques les plus utilisées. Ils sont McCabe, Métriques Halstead et lignes de code (LOC) métriques.

Chaque numéro de ligne du fichier CSV représente chacun de ces attributs, Y indique qu'il a détecté des pannes sujettes à des lignes de code, le tableau suivant montre les différents types de métriques et ces rôles :

Les Métriques de McCabe	CYCLOMATIC_COMPLEXITY - nombre cyclomatique (quantité de logique de décision) (V(g)). DESIGN_COMPLEXITY - quantité de logique impliquée dans les appels de sous-programmes (IV(G)). ESSENTIAL_COMPLEXITY - mesurer la quantité de logique mal structurée (ev(G)).
	LOC_BLANK - Compte de McCabe des lignes vides dans le module.
	LOC_CODE_AND_COMMENT - nombre de lignes contenant à la
LOC	fois du code et des commentaires dans le module.
Métriques	LOC_COMMENTS - nombre de lignes de code de commentaires dans le module.
	LOC_EXECUTABLE - le nombre de lignes de code exécutable pour un module (pas de blanc ni de commentaire).
	LOC_TOTAL - Le nombre total de lignes pour un module donné.
	NUM_OPERANDS - nombre total d'opérandes.
	NUM_OPERATORS - nombre total d'opérateurs.
	NUM_UNIQUE_OPERANDS - le nombre d'opérandes distincts.
Métriques des	NUM_UNIQUE_OPERATORS - le nombre d'opérations distinctes.
opérateurs	- Operators : traditionnel (+, ++,>), mots-clés (return, if, continue)
	- Operands: identifiants, constants

Chapitre 03 : SFP-NN : Apprentissage profond pour la prédiction des défauts logiciels | 44

	HALSTEAD_CONTENT - Le contenu en demi-longueur d'un module u = u1 + u2
Les métriques	HALSTEAD_DIFFICULTY : (taux d'erreur) proportionnel au nombre
de Halsted	d'opérateurs uniques.
	HALSTEAD_EFFORT (E) - La métrique d'effort à mi-course d'un module E = V L
	HALSTEAD_ERROR_EST- La métrique d'estimation d'erreur de
	Halstead d'un module B = E2 / 3 1000
	HALSTEAD_LENGTH (N) - le total de toute la longueur dans les méthodes de (opérande / opérateurs).
	HALSTEAD_LEVEL (L) - l'inverse de la tendance à l'erreur du programme.
	HALSTEAD_PROG_TIME (T)- La métrique de temps de programmation à mi-course d'un module T = E 18.
	HALSTEAD_VOLUME (V) - est le contenu informationnel du programme (bit) il décrit la taille d'implémentation d'un algorithme.
	label {Y,N} - module a / n'a pas un ou plusieurs défauts signalés (oui ou
Autres	non).
	BRANCH_COUNT - du graphique de flux.

Les variables d'un ensemble de données peuvent être liées pour de nombreuses raisons. Il peut être utile dans l'analyse des données et la modélisation pour mieux comprendre les relations entre les variables. La relation statistique entre deux variables est appelée leur corrélation.

Une corrélation peut être positive, ce qui signifie que les deux variables évoluent dans la même direction, ou négative, ce qui signifie que lorsque la valeur d'une variable augmente, les valeurs des autres variables diminuent. La corrélation peut également être neuronale ou nulle, ce qui signifie que les variables ne sont pas liées. Nous avons utilisé la carte thermique (en anglais : Correlation Heat Map) [53] pour présenter la corrélation entre les attributs de quelque ensemble de données.

Chapitre 03 : SFP-NN : Apprentissage profond pour la prédiction des défauts logiciels | 45

Chapitre 03 : SFP-NN : Apprentissage profond pour la prédiction des défauts logiciels | 46

La normalisation des données est une technique couramment utilisée qui transforme de grandes plages de valeurs de données en petites valeurs de plage (ou valeurs binaires). Notamment, nous effectuons une normalisation min-max car il s'agit d'une approche de normalisation couramment utilisée en raison de sa grande précision et de sa vitesse d'apprentissage élevée. De plus, la normalisation min-max ne modifie pas la distribution de l'ensemble de données [54].

Nous effectuons la normalisation des données pour les raisons suivantes. Premièrement, la gamme de mesures logicielles extraites varie considérablement. Deuxièmement, il est obligatoire lors de l'utilisation d'algorithmes d'apprentissage en profondeur. Enfin, cela peut réduire les erreurs d'estimation et le temps de calcul (requis dans le processus d'apprentissage). La normalisation min-max peut être définie dans la formule (1) comme suit:

où min (sm^') et max (sm^') représentent les valeurs minimales et maximales d'une métrique logicielle sm^', respectivement, sm^' représente une valeur de transformation logarithmique de

Chapitre 03 : SFP-NN : Apprentissage profond pour la prédiction des défauts logiciels | 47

la métrique, et la normalisation (?????? ') représente la valeur normalisée de ?????? '. Après la normalisation des données, le module m peut être défini comme suit:

Où ?? est un ensemble de métriques logicielles transformées en log et normalisées. [54] 2.3. Prédictions utilisant le CNN

Les avantages de l'utilisation de la capacité du CNN pour les taches de classification sont formés pendant le processus de rétro-propagation et l'introduction de couches de max pooling, cela s'est avéré utile dans beaucoup d'applications.

Les réseaux convolutifs se sont avérés efficaces pour diverses tâches telles que la classification des numéros d'écriture manuscrite, la classification des images médicales et la détection des visages. La performance promise nous incite à l'utiliser dans la prédiction de défauts logiciels.[55]

Dans le processus d'apprentissage du CNN, j'ai été guidé en obtenant la plus grande précision et en déterminant l'effet de la modification de l'architecture du modèle. Lorsqu'un paramètre (tel que le numéro d'époque) était modifié, il y avait une amélioration de la précision. Le paramètre a été modifié régulièrement et les meilleurs résultats obtenus ont été utilisés lors de ré-expérimentations afin d'obtenir le résultat satisfaisant.

Chapitre 03 : SFP-NN : Apprentissage profond pour la prédiction des défauts logiciels | 48

Les paramètres qui doivent être définis pour le réseau incluent les paramètres de la fonction d'activation, le nombre de couches cachées et d'autres hyperparamètres. Dans cette section nous allons présenter les paramètres de notre classifieur CNN.

Différents hyperparamètres ont été modifiés au cours de chaque cas de test, pour examiner l'impact de celui-ci sur la précision. Le réglage de l'hyperparamètre est important pour choisir les bons paramètres afin d'obtenir les résultats souhaités. Il n'y a pas de règles précises pour choisir exactement les bons paramètres, en général, le choix dépend du type et de la taille de l'ensemble de données d'apprentissage. Le choix des paramètres corrects est essentiel mais considéré comme une partie complexe de la formation du CNN. Cependant, le réglage de l'hyperparamètre dépend souvent de l'expérience plutôt que des connaissances théoriques. Les compromis sont intrinsèques à la sélection des paramètres en raison de restrictions telles que la limitation de la mémoire [56]

Pendant la phase expérimentale, et lorsque nous atteignons le meilleur nombre pour l'un de ces hyperparamètres, on commence alors à manipuler d'autres hyperparamètres pour obtenir le meilleur résultat. Après cela, nous comparons les valeurs qui améliorent les performances du CNN. Les valeurs qui n'ont pas eu d'effet positif sur les résultats de l'algorithme sont supprimés.

- Nombre d'époques : Une époque est le nombre de passages dans l'ensemble de données [56] Dans notre expérience, nous avons testé plusieurs nombre d'époques (jusqu'à 70 époques), pour déterminer le meilleur nombre d'époques pour que le réseau converge correctement.

- Taille du lot (Batchsize) : est le nombre d'échantillons d'apprentissage. Batchsize est utilisé pour contrôler de nombreuses prédictions qui doivent être faites à la fois et s'adapter au modèle. En général, la plus grande taille de lot nécessitait plus d'espace mémoire [56]. D'autre part, les tailles de petits lots sont préférables car elles tendent à produire une convergence dans un petit nombre d'époques.

- Nombre de couches cachées : De nombreux facteurs peuvent influencer grandement les performances des réseaux, tels qu'un certain nombre de couches cachées, des neurones dans la couche cachée. Le nombre de couches devient le critère le plus important dans l'architecture des réseaux [56]. Dans notre travail, et après plusieurs tests

Chapitre 03 : SFP-NN : Apprentissage profond pour la prédiction des défauts logiciels | 49

empiriques, nous avons opté pour quatre (04) couches de convolution, une couche Flatten et une couche FC pour générer le résultat de prédiction.

- Fonctions d'activation : La fonction d'activation d'un neurone artificiel définit la sortie de ce neurone en fonction de l'entrée ou de l'ensemble d'entrées. Chaque fonction d'activation prend une entrée x et exécute un calcul mathématique spécifique dessus. Les fonctions d'activation courantes utilisées dans le réseau de neurones profonds sont la fonction Sigmoid, Unité Linéaire Rectifiée (ReLU) et tangente hyperbolique.

La fonction Sigmoïde : fréquemment utilisé en rétro-propagation du gradient. C'est une extension appropriée de la non-linéarité qui limite les utilisations précédentes dans les réseaux de neurones. Elle présente également un degré de lissage adéquat [56] .

Unités linéaires rectifiées (ReLU): utilisé comme fonction d'activation pour les couches cachées dans notre réseau de neurones profonds. Elle est largement utilisée pour former un réseau beaucoup plus profond que les fonctions d'activation Sigmoïde ou Tanh. ReLU fournit un apprentissage plus rapide et plus efficace pour le réseau de neurones profonds sur des données complexes et de grande dimension. L'avantage le plus important de ReLU est qu'il ne nécessite pas de calcul coûteux, juste une comparaison et une multiplication. ReLU a une rétro propagation efficace sans problème d'explosion/ disparition du gradient, ce qui en fait un choix particulièrement approprié pour le réseau de neurones profond. [56]

Les fonctions ReLU et Sigmoïde ont été utilisé comme des fonctions d'activation dans notre réseau de neurones convolutifs. Afin de résumer les paramètres de notre réseau de neurones convolutifs, ces paramètres nous a permis d'obtenir des résultats prometteurs, la table 3.3 présente chaque hyperparamètre avec les valeurs appropriées

Chapitre 03 : SFP-NN : Apprentissage profond pour la prédiction des défauts logiciels | 50

Les couches de convolutions	Parameters
Conv1	Conv2D(128, kernel_size=1, activation='relu')
Conv2	Conv2D(64, kernel_size=1, activation='relu')
Conv3	Conv2D(32, kernel_size=1, activation='relu')
Conv4	Conv2D(16, kernel_size=1, activation='relu')
Flattening	Flatten()
Fully Connected	Sigmoïde

Les objectifs de cette thèse sont d'étudier les capacités et le potentiel des algorithmes d'apprentissage profond, d'améliorer les performances de SFP et de déterminer les meilleurs algorithmes qui pourraient être utilisés à cette fin.

Nous avons mené des expériences suivies d'analyses et de comparaisons pour vérifier l'efficacité des algorithmes d'apprentissage profond (CNN). Les expériences ont été appliquées sur 14 ensembles de données. Les résultats des expériences ont été évalués en utilisant l'exactitude, la perte. Enfin, l'analyse et les comparaisons ont été effectuées pour démontrer les objectifs de notre étude.

Prédiction de défauts logiciel utilisant des techniques d'apprentissage automatique

Chapitre 01 : Prédiction des défauts logiciels 18