Qu'est-ce qu'un réseau de neurones ?

Un réseau de neurones (neural network) est une structure composée d'éléments appelés neurones (neurons), qui sont des unités décisionnelles individuelles recevant un certain nombre d'entrées $x_1,x_2,\dots ,x_n$ et produisant une sortie $y$, comme illustré à la Figure 7.2. La manière dont la sortie est déterminée par les entrées peut être très complexe. De plus, deux neurones distincts peuvent se comporter de manière tout à fait différente face aux mêmes entrées.

Figure 7.2 Neurone individuel dans un réseau de neurones

Le réseau de neurones lui-même peut être constitué de centaines, de milliers, voire de millions de neurones reliés les uns aux autres en couches, c'est-à-dire des groupes de neurones qui reçoivent tous les mêmes entrées des couches précédentes et transmettent des signaux de manière agrégée à la couche suivante. Il y a toujours au moins deux couches : la couche d'entrée (input layer) (qui contient les neurones recevant les données d'entrée initiales) et la couche de sortie (output layer) (qui contient les neurones utilisés pour interpréter la réponse ou fournir des informations de classification), ainsi qu'un certain nombre de couches cachées (hidden layers) (situées entre la couche d'entrée et la couche de sortie). La Figure 7.3 présente un schéma de réseau de neurones simple à titre de référence.

Figure 7.3 Schéma d'un réseau de neurones. Ce réseau de neurones comporte quatre couches, dont deux sont des couches cachées. Il y a trois neurones d'entrée et un neurone de sortie. Dans cet exemple, tous les nœuds des couches adjacentes sont connectés, mais certains modèles de réseaux de neurones peuvent ne pas inclure toutes ces connexions (voir, par exemple, les réseaux de neurones convolutifs dans Introduction à l'apprentissage profond).

L'objectif principal d'un réseau de neurones est de classifier des données complexes. Les problèmes pour lesquels les réseaux de neurones sont particulièrement bien adaptés comprennent notamment :

• La reconnaissance d'images, y compris la reconnaissance faciale, l'identification de lettres et de symboles manuscrits, ainsi que la classification d'éléments d'images. Il s'agit d'un domaine d'innovation majeur, doté d'outils puissants tels que TensorFlow développé par Google et PyTorch développé par Meta.
• La reconnaissance vocale, comme le service Cloud Speech-to-Text de Google, qui offre une transcription précise de la parole et la traduction dans diverses langues.
• Les systèmes de recommandation, qui sont utilisés pour diffuser des publicités en ligne en fonction des habitudes de navigation de chaque utilisateur, ont été développés et utilisés par Amazon, Meta, Netflix et de nombreuses autres grandes entreprises pour cibler leurs marchés.
• La détection d'anomalies, développée pour faciliter la détection des fraudes, la sécurité des données et l'analyse/correction d'erreurs en repérant les valeurs aberrantes dans des jeux de données volumineux et complexes. On peut citer par exemple Azure Anomaly Detector de Microsoft, capable de détecter des anomalies dans des données de séries temporelles.
• Les véhicules autonomes et la robotique, notamment la technologie Autopilot de Tesla, occupent une place de plus en plus prépondérante à mesure que l'automatisation allège certaines tâches routinières du quotidien et améliore l'efficacité dans les entreprises, la fabrication et les transports.
• L'art génératif, qui comprend par exemple les arts visuels, la musique, la vidéo et la poésie, exploite d'immenses réserves de la création humaine pour produire des variations inédites.
• Le texte prédictif, y compris les modèles de traitement du langage naturel tels que ChatGPT (voir Réseaux de neurones convolutifs).

Neurones, poids, biais et fonctions d'activation

Le mode de fonctionnement des neurones (neurons) dans un réseau de neurones est supposé être similaire, ou analogue, à celui des neurones dans le cerveau. L'entrée du réseau de neurones est injectée dans les neurones de la couche d'entrée. Chaque neurone la traite ensuite et produit une sortie, qui est à son tour transmise aux neurones de la couche suivante. Les neurones individuels n'envoient de signaux, c'est-à-dire ne s'activent, que s'ils reçoivent l'entrée requise pour s'activer. (L'activation est le processus consistant à envoyer un signal de sortie après avoir reçu les signaux d'entrée appropriés.) Après avoir traversé un certain nombre de couches cachées, la sortie de la dernière couche cachée alimente la couche de sortie. Enfin, la sortie de cette couche finale est interprétée selon la nature du problème. S'il n'y a qu'un seul neurone de sortie, l'interprétation peut être vrai si ce neurone est activé ou faux dans le cas contraire. Pour les réseaux de neurones utilisés afin de classer des entrées dans différentes catégories (par exemple, la reconnaissance de chiffres), il y a généralement un neurone de sortie par classe. Celui qui est le plus activé indique la classification retenue, comme l'illustre la Figure 7.4.

Figure 7.4 Neurones de sortie. Sur cette figure, il y a quatre neurones de sortie, étiquetés A, B, C et D. Puisque B présente le niveau d'activation le plus élevé, la sortie du réseau de neurones est B.

Chaque connexion d'un neurone à un autre est associée à deux paramètres. Le poids (weight) est une valeur $w$ par laquelle est multiplié le signal entrant, ce qui détermine concrètement l'intensité de la connexion. Le biais (bias) est une valeur $b$ qui est ajoutée au signal pondéré, rendant le neurone plus susceptible (ou moins susceptible, si $b$ est négatif) de s'activer pour une entrée donnée. Les valeurs de $w$ et de $b$ peuvent être positives, négatives ou nulles. Une fois le poids et le biais appliqués, le résultat est passé dans une fonction d'activation (activation function), qui est une fonction non décroissante $f$ déterminant si le neurone s'active et, le cas échéant, avec quelle intensité. (Vous verrez cela plus loin à la Figure 7.6.)

Considérons le cas le plus simple qui soit : un neurone doté d'une entrée unique $x$ et d'une sortie $y$. La circulation du signal à travers le neurone suit alors la formule $y=f(wx+b)$. Par exemple, supposons que la valeur d'entrée soit $x=0.87$, avec un poids $w=0.53$ et un biais $b=-0.12$. Le signal commence par être combiné sous la forme $wx+b=\left(0.53\right)\left(0.87\right)+(-0.12)=0.3411$. Cette valeur est ensuite fournie en entrée à la fonction d'activation pour produire $y=f\left(0.3411\right)$. Dans la section suivante, nous examinerons diverses fonctions d'activation utilisées dans les réseaux de neurones.

Lorsqu'il y a plusieurs entrées, $x_1,x_2,\dots ,x_n$, chacune est affectée par son propre poids. Généralement, le biais est considéré comme une propriété du neurone lui-même et influe donc de la même manière sur l'ensemble des entrées. Plus précisément, les entrées sont d'abord multipliées par leurs poids respectifs, le résultat est sommé, puis le biais est ajouté. Enfin, la fonction d'activation est appliquée pour obtenir le signal de sortie.

$$y=f(w_1{x}_1+w_2{x}_2+\dots +w_n{x}_n+b)=f(\left(\sum _{i=1}^n{w}_i{x}_i\right)+b)$$

Les poids et les biais sont des paramètres que le réseau de neurones apprend au cours du processus d'entraînement, un sujet que nous expliquerons dans Rétropropagation.

Un réseau de neurones typique peut comporter des centaines ou des milliers d'entrées pour chaque neurone, ce qui rend l'équation difficile à manipuler sous cette forme. Il s'avère plus pratique de considérer l'ensemble des entrées $x_1,x_2,\dots ,x_n$ comme les composantes d'une structure mathématique unique, appelée un vecteur (vector). Un vecteur est simplement une liste ordonnée de nombres, c'est-à-dire ${x=(x}_1,x_2,\dots ,x_n)$. (Remarque : dans cet ouvrage, nous utilisons des lettres en gras pour représenter les vecteurs. De plus, les composantes d'un vecteur sont indiquées entre parenthèses. Certains ouvrages utilisent des conventions de notation différentes.) Le nombre de composantes d'un vecteur est appelé sa dimension ; ainsi, par exemple, le vecteur $(5,0,-2,1.2,\pi )$ est de dimension 5. Certaines opérations arithmétiques sont définies sur les vecteurs.

• Vectors of the same dimension can be added: If $x={(x}_1,x_2,\dots ,x_n)$ and ${y=(y}_1,y_2,\dots ,y_n)$, then ${x+y=(x}_1+y_1,x_2+y_2,\dots ,x_n+y_n)$.
• Any real number can be multiplied to a vector: ${kx=k(x}_1,x_2,\dots ,x_n)={(kx}_1,k{x}_2,\dots ,k{x}_n)$.
• Le produit scalaire de deux vecteurs de même dimension donne un nombre réel (et non un vecteur) et se définit par :
  
  $$\begin{array}{rcl}x·y& =& {(x}_1,x_2,\dots ,x_n)·{(y}_1,y_2,\dots ,y_n)=\sum _{i=1}^n{x}_i{y}_i\\ & =& x_1{y}_1+x_2{y}_2+x_3{y}_3+\dots +x_n{y}_n\end{array}$$

Si les entrées et les poids sont considérés comme des vecteurs, respectivement $x={(x}_1,x_2,\dots ,x_n)$ et $w={(w}_1,w_2,\dots ,w_n)$, la formule peut alors s'exprimer de manière plus concise par :

$$y=f(w·x+b)$$

Par exemple, si $w=(0.3,-0.1,0.9)$, $x=(1.2,0.4,-0.6)$ et $b=0.1$, alors

$$w·x+b=(0.3\left)\right(1.2)+(-0.1)\left(0.4\right)+\left(0.9\right)(-0.6)+0.1=-0.12$$

Dans cet exemple, la sortie est donc $y=f(-0.12)$, dont la valeur exacte dépend de la fonction d'activation $f\left(x\right)$ choisie.

Types de fonctions d'activation

Les fonctions d'activation sont de plusieurs types. En voici quelques-unes parmi les plus courantes.

1. Fonction en escalier (step function), $f\left(x\right)=\{\begin{array}{l}0,\mathrm{if}x<c\\ 1,\mathrm{if}x\ge c\end{array}$. La valeur de $c$ sert de seuil. Le neurone ne s'active que lorsque l'entrée est au moins égale au paramètre $c$.
2. Fonction sigmoïde (sigmoid function), $\sigma \left(x\right)=\frac{1}{1+e^{-x}}$. Remarquez qu'il s'agit de la même fonction sigmoïde que celle utilisée dans la régression logistique (voir Classification à l'aide de l'apprentissage automatique). Les valeurs de sortie ont tendance à être proches de 0 lorsque $x$ est négatif et proches de 1 lorsque $x$ est positif, avec une transition progressive entre les deux.
3. Fonction tangente hyperbolique (tanh) (hyperbolic tangent (tanh) function), $\text{tanh }x=\frac{e^x-e^{-x}}{e^x+e^{-x}}$. Les valeurs de sortie sont du même signe que $x$, avec une transition continue par 0.
4. Fonction unité linéaire rectifiée (ReLU) (rectified linear unit (ReLU) function), $\text{ReLU}\left(x\right)=\text{max}(0,x)$. La fonction ReLU vaut 0 pour les valeurs de $x$ négatives et est égale à l'entrée lorsque $x$ est positif.
5. Fonction Leaky ReLU (leaky ReLU function), $\text{LReLU}\left(x\right)=\text{max}(cx,x)$, pour un petit paramètre positif $c$. La fonction Leaky ReLU se comporte de façon très proche de ReLU, sauf que les valeurs deviennent progressivement plus négatives lorsque $x$ devient plus négatif. Souvent, la valeur optimale du paramètre de « fuite » $c$ est déterminée pendant la phase d'entraînement.
6. Fonction Softplus (softplus function), $f\left(x\right)=\text{ln}(1+e^x)$, qui est une version lissée de la fonction ReLU.

La Figure 7.5 montre les courbes des fonctions énumérées. Une caractéristique essentielle des fonctions d'activation est qu'elles sont non linéaires (nonlinear), ce qui signifie qu'elles ne sont pas de simples droites, $f\left(x\right)=mx+b$.

Une autre fonction d'activation importante dans les réseaux de neurones, softmax, prend en entrée un vecteur de nombres réels et produit un vecteur de valeurs normalisées dans l'intervalle entre 0 et 1, que l'on peut interpréter comme une distribution de probabilité discrète. (Rappelez-vous, d'après Distributions de probabilité discrètes et continues, que les distributions de probabilité discrètes fournissent des mesures de probabilité ou de vraisemblance qu'un nombre fini de valeurs se réalisent.) La formule de softmax est :

$$\sigma (x_1,x_2,\dots ,x_n)=(\frac{e^{x_1}}{D},\frac{e^{x_2}}{D},\dots ,\frac{e^{x_n}}{D})$$

où $D=e^{x_1}+e^{x_2}+\dots +e^{x_n}$. Nous rencontrerons l'activation softmax dans un exemple de la section Rétropropagation.

Figure 7.5 Graphiques des fonctions d'activation. En haut, de gauche à droite, fonctions (a) en escalier, (b) sigmoïde et (c) tangente hyperbolique (tanh). En bas, de gauche à droite, fonctions (d) ReLU, (e) LReLU et (f) softplus.

Exemple 7.1

Problème

Un neurone simple possède quatre entrées, $x_1,x_2,x_3,x_4$, et une sortie, $y$. Les poids des quatre entrées sont $w_1=0.34$, $w_2=0.07$, $w_3=0.59$ et $w_4=-0.21$. Le biais du neurone est $b=0.19$. Trouvez la sortie dans chacun des cas suivants.

1. $(x_1,x_2,x_3,x_4)=(1,0,0,1)$. Fonction d'activation : ReLU.
2. $(x_1,x_2,x_3,x_4)=(1,0,0,1)$. Fonction d'activation : sigmoïde.
3. $(x_1,x_2,x_3,x_4)=(1,0,0,1)$. Fonction d'activation : en escalier, $f\left(x\right)=\{\begin{array}{l}0,\mathrm{if}x<0.5\\ 1,\mathrm{if}x\ge \mathrm{0.\; 5}\end{array}$.
4. $(x_1,x_2,x_3,x_4)=(0,2.3,-1.6,0.8)$. Fonction d'activation : softplus.

Solution

Mise en place pour chaque cas :

$$y=f(w·x+b)=f(w_1{x}_1+w_2{x}_2+w_3{x}_3+w_4{x}_4+b)=f(0.34x_1+0.07x_2+0.59x_3-0.21x_4+0.19)$$

1. $\text{ReLU}\left(0.34\right(1)+0.07(0)+0.59(0)-0.21(1)+0.19)=\text{ReLU}(0.32)=0.32$, puisque $0.32>0$
2. $\sigma \left(0.32\right)=\frac{1}{1+e^{-0.32}}=0.58$ (Remarque : 0,32 a déjà été calculé au point a.)
3. $f\left(0.32\right)=0$, puisque $0.32<0.5$ (Remarque : 0,32 a déjà été calculé au point a.)
4. $f\left(0.34\right(0)+0.07\left(2.3\right)+0.59(-1.6)-0.21(0.8)+0.19)=f(-0.761)=\text{ln}(1+e^{-0.761})=-0.761$

Dans la section suivante, nous explorons les réseaux de neurones qui utilisent la plus simple des fonctions d'activation : la fonction en escalier.

Perceptrons

Bien que l'idée d'utiliser des structures calquées sur les neurones biologiques ait existé avant l'apparition de ce que nous considérons aujourd'hui comme des réseaux de neurones, une avancée majeure a eu lieu au milieu du XXe siècle. En 1957, Frank Rosenblatt a mis au point le perceptron, un type de réseau de neurones à une seule couche conçu pour les tâches de classification binaire — autrement dit, un réseau de neurones dont la sortie pouvait être « vrai » ou « faux » (voir la Figure 7.7). Après des succès initiaux, les progrès de l'IA ont été freinés par les capacités restreintes des programmes et le manque de puissance de calcul, entraînant une période de stagnation appelée « hiver de l'IA ». Malgré ces revers, de nouveaux développements sont apparus dans les années 1980, conduisant au perceptron multicouche (MLP) (multilayer perceptron (MLP)), qui constitue le paradigme fondamental des réseaux de neurones comportant plusieurs couches cachées.

Le perceptron monocouche apprend les poids au moyen d'une règle d'apprentissage simple, appelée règle d'apprentissage du perceptron.

1. Initialiser les poids ($w$) et le biais ($b$) avec de petites valeurs aléatoires.
2. Pour chaque entrée ($x$) de l'ensemble d'entraînement :
   1. Calculer les prédictions $\hat{y}=f(w·x+b)$, où $f$ est la fonction en escalier,
      $$f\left(x\right)=\{\begin{array}{l}0,\mathrm{if}x<0\\ 1,\mathrm{if}x\ge 0\end{array}$$
   2. Calculer l'erreur $E=y-\hat{y}$, où $y$ est la valeur réelle ou souhaitée correspondant à $x$. Notez que $E$ peut être positif ou négatif. Une valeur de $E$ positive implique que les poids et/ou le biais sont trop faibles et doivent être augmentés. Une valeur de $E$ négative implique le contraire.
   3. Mettre à jour les poids et les biais selon les formules suivantes, où $h$ est une petite constante positive contrôlant le taux d'apprentissage. Souvent, la modification des poids et des biais sera minime et ne produira pas immédiatement un impact important sur l'entrée. Cependant, au fil d'entraînements répétés, le perceptron va apprendre les valeurs appropriées de $w$ et de $b$ pour obtenir la sortie désirée.
      
      $$w\leftarrow w+hEx$$
      $$b\leftarrow b+hE$$

Par exemple, supposons qu'un perceptron à trois entrées possède actuellement les poids $w=(0.5,0.7,0.1)$ et le biais $b=-0.9$. Pour l'entrée $x=(0.6,1,0)$, on obtient :

Supposons que la sortie réelle aurait dû être $y=0$. Il y a donc une erreur de $E=0-1=-1$. Si le taux d'apprentissage est $h=0.1$, les poids et le biais seront alors mis à jour comme suit :

Pour la même entrée, le perceptron produit désormais la valeur :

Dans cet exemple simple, la valeur $\hat{y}$ est passée de 1 à 0, éliminant ainsi l'erreur. Cependant, rien ne garantit que le perceptron classera toutes les entrées sans erreur, quel que soit le nombre d'étapes d'entraînement effectuées.

Construire un réseau de neurones simple

Dans Qu'est-ce que la science des données ?, à l'Exemple 1.7, nous avons examiné le jeu de données Iris pour nous familiariser avec les formats et les structures de jeux de données. Dans cette section, nous utiliserons le jeu de données Iris, iris.csv, pour créer un réseau de neurones à quatre entrées et un neurone de sortie (pour l'essentiel, un perceptron simple) afin de classer les iris en setosa ou non setosa, en fonction de quatre caractéristiques : la longueur des sépales (SL), la largeur des sépales (SW), la longueur des pétales (PL) et la largeur des pétales (PW), toutes mesurées en centimètres. Le jeu de données Iris iris.csv contient 150 échantillons d'iris, répartis à raison de 50 pour chaque espèce : setosa, versicolor et virginica. Pour les besoins de cet exemple, les 100 premières lignes de données ont été sélectionnées pour l'entraînement et le test, en consacrant 75 % des données à l'entraînement et les 25 % restants au test. (Rappelez-vous, d'après Prise de décision à l'aide des bases de l'apprentissage automatique, qu'il est de bonne pratique d'utiliser environ 70 % à 80 % des données pour l'entraînement, le reste étant réservé au test.) Le réseau sera entraîné à l'aide de la règle d'apprentissage du perceptron, mais au lieu d'employer la fonction en escalier, la fonction d'activation sera la tangente hyperbolique, $\text{tanh}x=\frac{e^x-e^{-x}}{e^x+e^{-x}}$, choisie ici simplement à des fins d'illustration.

Le modèle du réseau de neurones est illustré à la Figure 7.6.

Figure 7.6 Modèle de réseau de neurones perceptron simple. Ici, $x_1,x_2,x_3,x_4$ sont les entrées, $w_1,w_2,w_3,w_4$ représentent les poids et $b$ représente le biais. La sortie, ou réponse, est notée $y$.

The inputs $(x_1,x_2,x_3,x_4)$ will take the values of SL, SW, PL, and PW, respectively. There are four corresponding weights $(w_1,w_2,w_3,w_4)$ and one bias value $b$, which are applied to the input layer values, and then the result is fed into the tanh function to obtain the output $y$. Thus, the formula used to produce the predicted $y$ values, denoted by $\hat{y}$, is:

Dans ce modèle très simplifié, nous interprétons la valeur de $y$ comme suit :

• Si $\hat{y}>0$, classer l'entrée comme setosa.
• Si $\hat{y}<0$, classer l'entrée comme non setosa.

Pour mesurer l'erreur de classification, nous devons choisir des valeurs cibles concrètes auxquelles comparer nos sorties. Posons la valeur cible pour la classification setosa égale à $1$, tandis que la cible pour la classification non setosa sera de $-1$. Ce choix est raisonnable puisque les valeurs de $\text{tanh}\left(x\right)$ tendent vers $1$ lorsque $x$ tend vers l'infini positif et vers $-1$ lorsque $x$ tend vers l'infini négatif.

Par exemple, si après l'entraînement, les poids idéaux obtenus sont $(w_1,w_2,w_3,w_4)=(-0.2,0.6,-0.9,0.1)$ et que le biais vaut $b=0.5$, alors la réponse face à une entrée $(x_1,x_2,x_3,x_4)=(5.1,3.5,1.4,0.2)$ sera :

Comme $\hat{y}>0$, on classe l'entrée comme setosa. Bien entendu, la question naturelle qui se pose est : comment obtient-on ces valeurs particulières de poids et de biais au départ ? Cette tâche complexe convient parfaitement à un ordinateur. Nous allons utiliser Python pour entraîner le perceptron.

La bibliothèque Python sklearn.datasets dispose d'une fonction, load_iris, qui charge automatiquement le jeu de données Iris, ce qui vous évite d'importer le fichier iris.csv. Les autres modules importés depuis sklearn sont Perceptron, utilisé pour construire le modèle de perceptron, et train_test_split, utilisé pour diviser de manière aléatoire un jeu de données en un ensemble de test et un ensemble d'entraînement. Nous utiliserons ici une répartition de 75 % pour l'entraînement et 25 % pour le test, prise en charge par le paramètre test_size=0.25. Nous allons également renormaliser les données pour que toutes les caractéristiques contribuent équitablement au modèle. En Python, cela s'effectue au moyen de StandardScaler, qui renormalise les caractéristiques du jeu de données de telle sorte que la moyenne soit égale à 0 et l'écart type à 1. Enfin, accuracy_score sert à évaluer l'exactitude de la classification.

    
    # import the sklearn library (specific modules)
    from sklearn.datasets import load_iris
    from sklearn.linear_model import Perceptron
    from sklearn.model_selection import train_test_split
    from sklearn.preprocessing import StandardScaler
    from sklearn.metrics import accuracy_score
    
    # Load the Iris dataset
    iris = load_iris()
    X = iris.data[:100] # Only taking first 100 samples for binary classification
    y = iris.target[:100] # "0 for setosa", 1 for "not setosa"
    
    # Split the dataset into training and testing sets
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25)
    
    # Standardize features by removing the mean and scaling to unit variance
    scaler = StandardScaler()
    X_train_scaled = scaler.fit_transform(X_train)
    X_test_scaled = scaler.transform(X_test)
    
    # Initialize and train the perceptron
    perceptron = Perceptron()
    perceptron.fit(X_train_scaled, y_train)
    
    # Make predictions on the test set
    y_pred = perceptron.predict(X_test_scaled)
    
    # Calculate accuracy
    accuracy = accuracy_score(y_test, y_pred)
    print("Accuracy:", accuracy)
    

Accuracy: 1.0

Comme le jeu de données était relativement restreint (100 lignes) et bien structuré, le modèle de perceptron a été capable de classifier les données avec une exactitude de 100 % (« Accuracy: 1.0 »). Dans des situations réelles, où les jeux de données sont plus vastes et moins réguliers, on ne peut pas s'attendre à une exactitude de 100 %. Le modèle pourrait également présenter un surapprentissage important, ce qui entraînerait une variance élevée lors de la classification de données n'appartenant pas au jeu de données initial.

Voici comment utiliser le modèle de perceptron que nous venons de créer pour classer de nouvelles données (extérieures au jeu de données d'origine) :

    
    # Assume you have new inputs stored in a variable called 'new_inputs'
    new_inputs = [[5.1, 3.5, 1.4, 0.2], # Example input 1
          [6.3, 2.9, 5.6, 1.8] # Example input 2
          ]
    
    # Standardize the new inputs using the same scaler used for training
    new_inputs_scaled = scaler.transform(new_inputs)
    
    # Use the trained perceptron model to make predictions on the new inputs
    predictions = perceptron.predict(new_inputs_scaled)
    
    # Display the predictions
    for i, prediction in enumerate(predictions):
     print(f"Input {i+1} prediction: {'Setosa' if prediction == 0 else 'Not Setosa'}")
    

Input 1 prediction: Setosa
Input 2 prediction: Not Setosa