IBM lance une bibliothèque open source dédiée à la sécurisation des systèmes
Qui s’appuient sur les techniques d’intelligence artificielle

Dans un billet de blog paru il y a peu, IBM Research Ireland annonce la disponibilité d’Adversarial Robustness Toolbox (ART), une bibliothèque open source pour sécuriser les systèmes qui s’appuient sur les techniques d’intelligence artificielle. Une équipe de la division recherche d’International Business Machines a également procédé à la présentation de cette dernière dans le cadre de la conférence RSA qui s’est tenue du 16 au 20 avril dernier aux États-Unis.

Reconnaissance du son, du langage parlé et même des images, les systèmes d’intelligence artificielle ne cessent d’impressionner, et ce, dans plusieurs filières : assistants personnels intelligents, enceintes connectées, etc. Il y a seulement que des individus malveillants bien au fait de leurs principes de fonctionnement peuvent les amener à se tromper. L’une des façons de procéder est de perturber de façon furtive les données soumises à une intelligence artificielle pour analyse afin de créer un dysfonctionnement de cette dernière, ce qui s’appelle attaque « adversarial » dans le jargon IA.

Une publication de chercheurs en intelligence artificielle employés par Google illustre ce concept. Ces derniers ont montré que des modifications quasi invisibles à l’œil nu sur l’image d’un panda peuvent perturber une intelligence artificielle au point qu’elle se mette à identifier un grand singe.

Nom : tromper IA.png Affichages : 2625 Taille : 159,8 Ko

Une autre équipe de chercheurs d’universités américaines a montré qu’il est possible d’étendre cette catégorie d’attaques au monde réel. En positionnant des autocollants blancs spécialement conçus sur des panneaux routiers (un aspect auquel peu de monde prêtera attention), ils sont parvenus à faire dire à une intelligence artificielle qu’un panneau de stop est un panneau de limitation de vitesse. Inquiétant lorsqu’on sait que de l’utilisation de tels systèmes va aller croissant et lorsqu’on prend en compte l’enjeu d’une analyse.

La bibliothèque ART développée en python permet d’entraîner un modèle d’intelligence artificielle puis de le soumettre à des attaques adversarial en s’appuyant sur les modules d’attaque (7 modules). L’enchaînement logique est l’utilisation des modules de défense (4 fournis) pour tester la robustesse de l’intelligence artificielle et l’améliorer.

ART en est à sa première release (version 0.1) et, pour le moment, permet l’entraînement des réseaux de neurones implémentés à l’aide des frameworks Tensorflow ou Keras. Ci-dessous, le code source – sous licence MIT – de l’un des modèles de réseaux de neurones à convolution basé sur le modèle séquentiel Keras.

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
from __future__ import absolute_import, division, print_function
 
from keras.models import Sequential, model_from_json
from keras.layers import Dense, Activation, Flatten, Conv2D, MaxPooling2D, Dropout
from keras.layers.normalization import BatchNormalization
 
from art.classifiers.classifier import Classifier
 
 
def mnist_layers(input_shape, nb_filters):
 
    layers = [Conv2D(nb_filters, (8, 8), strides=(2, 2), padding="same", input_shape=input_shape),
              "activation",
              Conv2D((nb_filters * 2), (6, 6), strides=(2, 2), padding="valid"),
              "activation",
              Conv2D((nb_filters * 2), (5, 5), strides=(1, 1), padding="valid"),
              "activation",
              Flatten()]
 
    return layers
 
 
def cifar10_layers(input_shape, nb_filters):
 
    layers = [Conv2D(nb_filters // 2, (3, 3), padding="same", input_shape=input_shape),
              "activation",
              MaxPooling2D(pool_size=(2, 2)),
              Dropout(0.5),
              Conv2D(nb_filters, (3, 3), padding="valid"),
              "activation",
              MaxPooling2D(pool_size=(2, 2)),
              Dropout(0.5),
              Flatten(),
              Dense(500),
              "activation",
              Dropout(0.5)]
 
    return layers
 
 
[docs]class CNN(Classifier):
    """
    Implementation of a convolutional neural network using Keras sequential model
    """
    def __init__(self, input_shape=None, include_end=True, act='relu', bnorm=False, input_ph=None, nb_filters=64,
                 nb_classes=10, act_params={}, model=None, defences=None, preproc=None, dataset="mnist"):
 
        """Instantiates a ConvolutionalNeuralNetwork model using Keras sequential model
 
        :param tuple input_shape: shape of the input images
        :param bool include_end: whether to include a softmax layer at the end or not
        :param str act: type of the intermediate activation functions
        :param bool bnorm: whether to apply batch normalization after each layer or not
        :param input_ph: The TensorFlow tensor for the input
                    (needed if returning logits)
                    ("ph" stands for placeholder but it need not actually be a
                    placeholder)
        :param int nb_filters: number of convolutional filters per layer
        :param int nb_classes: the number of output classes
        :param dict act_params: dict of params for activation layers
        :rtype: keras.model object
        """
        if model is None:
            model = Sequential(name='cnn')
            layers = []
 
            if "mnist" in dataset:
                layers = mnist_layers(input_shape, nb_filters)
            elif "cifar10" in dataset:
                layers = cifar10_layers(input_shape, nb_filters)
            elif "stl10" in dataset:
                raise NotImplementedError("No CNN architecture is defined for dataset '{0}'.".format(dataset))
 
            for layer in layers:
 
                if layer == "activation":
                    model.add(self.get_activation(act, **act_params))
                    if bnorm:
                        model.add(BatchNormalization())
                else:
                    model.add(layer)
 
            model.add(Dense(nb_classes))
 
            if include_end:
                model.add(Activation('softmax'))
 
        super(CNN, self).__init__(model, defences, preproc)
IBM Research Ireland assure que le support sera étendu à d’autres frameworks comme PyTorch ou MXNet dans de futures versions de la bibliothèque. À noter également que le champ d’application actuel d’ART est la sécurisation des systèmes de reconnaissance visuelle. Là également, IBM Research Ireland promet des extensions pour la reconnaissance de la parole, du texte, etc. dans le cadre de prochaines releases.

Sources

Blog

GitHub

Publication de recherche Google

Publication de l’équipe de chercheurs américains

Et vous ?

Qu’en pensez-vous ?

Voir aussi

Qui devra être tenu pour responsable si une intelligence artificielle fait un mauvais diagnostic induisant un médecin en erreur ?

Watson, l'Intelligence artificielle d'IBM découvre chez une patiente une leucémie rare qui n'avait pas pu être détectée par les médecins

Une intelligence artificielle bat des experts de l'armée de l'air américaine dans des simulations de combats aériens

Google utilise l'intelligence artificielle pour détecter la rétinopathie diabétique qui expose près de 415 millions de diabétiques à la cécité