Intelligence artificielle

Modèle de base de Perceptron utilisant la méthode des moindres carrés – Benjamin Obi Tayo Ph.D.

Modèle de base de Perceptron utilisant la méthode des moindres carrés - Benjamin Obi Tayo Ph.D.


Tout comme les milliards de neurones qui composent le système nerveux humain, le perceptron est l'unité de base de l'intelligence artificielle. Chaque pensée, action, émotion ou décision que nous prenons reflète les activités du système nerveux, qui est un système maître qui contrôle et communique avec toutes les parties de votre corps. L'intelligence biologique repose sur ce mécanisme complexe de milliards de neurones organisés en différentes couches qui communiquent les uns avec les autres par des signaux électriques et chimiques.

Pour comprendre comment l’intelligence biologique est produite, il est important de comprendre comment fonctionne l’élément de base appelé neurone.

Le neurone biologique a 3 fonctions principales:

  1. Entrée sensorielle. Le neurone utilise ses dendrites (régions réceptives) pour surveiller les changements se produisant tant à l'intérieur qu'à l'extérieur du corps. Les informations recueillies sont appelées entrées sensorielles.
  2. L'intégration: Le système du corps cellulaire traite et interprète les entrées sensorielles et décide de ce qui doit être fait à chaque instant, un processus appelé intégration. Si l'entrée sensorielle est inférieure à un certain seuil, le signal sensoriel n'est pas activé.
  3. Sortie du moteur. Si le signal d'entrée sensoriel dépasse un certain seuil, le neurone produit une sortie qui est transmise via des espaces synaptiques par des neurotransmetteurs. Les neurotransmetteurs vont soit exciter soit inhiber un neurone proche.

Semblable à l'intelligence biologique, l'intelligence artificielle est produite par un réseau complexe de blocs de construction de base appelé perceptron. Le perceptron fonctionne selon le même principe qu'un neurone:

  1. Contribution
  2. L'intégration
  3. Sortie

Nous allons nous concentrer ici sur la façon de construire un modèle de base de percétron en python. Ces connaissances sont fondamentales pour comprendre des modèles plus avancés tels que les réseaux de neurones, qui sont des systèmes complexes de milliers et de milliards de perceptrons, capables de produire des systèmes intelligemment artificiels, tels que des voitures autonomes.

Modèle de base de Perceptron

Python apprend paquet contient plusieurs classificateurs tels que le Perceptron, SupportVectorClassifier, LogisticRegressionClassifer, DecisionTreeClassifier, RandomForestClassifier, et Classificateur KNN. Bien qu'il soit important d'utiliser ces algorithmes d'apprentissage machine prêts à l'emploi, chaque débutant sur le terrain doit maîtriser les bases du fonctionnement de ces algorithmes. Envisagez le perceptron pour commencer votre parcours dans les réseaux de neurones et les modèles d’apprentissage en profondeur.

Dans cet exemple, nous construisons un modèle de perceptron simple dans lequel les poids d'apprentissage sont calculés à l'aide de la méthode des moindres carrés.

Le modèle de perceptron comporte les quatre étapes principales suivantes:

  1. Entraînement
  2. Activation
  3. Quantification
  4. Prédiction

X représente l'attribut ou la matrice de prédicteur, et y représente la classe. Nous illustrerons notre modèle à l'aide du jeu de données Iris. L'ensemble de données contient les informations d'attribut suivantes:

  1. longueur des sépales en cm
  2. largeur des sépales en cm
  3. longueur des pétales en cm
  4. largeur des pétales en cm

Les trois classes sont

  1. Iris Setosa
  2. Iris Versicolor
  3. Iris Virginica

Pour simplifier, nous effectuons une classification binaire. Nous utilisons les deux classes de fleurs Setosa et Versicolor pour des raisons pratiques. Cependant, l'algorithme de perceptron peut être étendu à la classification multi-classes - par exemple, à l'aide de la technique One-vs.-All.

Ce code applique l'algorithme de classification des perceptrons à l'ensemble de données iris. Les poids utilisés pour calculer la fonction d’activation sont calculés à l’aide de la méthode des moindres carrés. Cette méthode est différente de la règle de Perceptron d’origine de Rosenblatt dans laquelle les poids sont calculés de manière récursive. Pour plus d’informations sur l’implémentation de l’algorithme de perceptron de Rosenblatt, voir le livre suivant: “Apprentissage Machine Python”De Sebastian Raschka.

Importer les bibliothèques nécessaires

importer des pandas en tant que pdimporter numpy en tant que npimporter matplotlib.pyplot en tant que pltfrom sklearn.model_selection import train_test_split

Définir un objet classificateur Perceptron

classe Perceptron (objet):
"" "Classificateur Perceptron utilisant la méthode des moindres carrés pour calculer les poids.

Les attributs
-----------
w: 1d-array
Poids après ajustement.
"" "
def fit (self, X, y):
"" "Adapter les données d'entraînement.

Paramètres
----------
X: {comme un tableau}, forme = [n_samples, n_features]
Vecteurs d'apprentissage, où n_samples est le nombre d'échantillons et n_features est le nombre d'entités.
y: semblable à un tableau, forme = [n_samples]
Valeurs cibles.
Résultats
-------
self: objet
"" "
self.w = np.dot (np.linalg.inv (np.dot (X.T, X)), np.dot (X.T, y))
retourner soi-même

def pred (auto, X):
"" "Renvoie l'étiquette de la classe après l'étape de l'unité" ""
return np.where (np.dot (X, self.w)> = 0.0, 1, -1)

Importer un jeu de données Iris

df = pd.read_csv ('iris.data.csv', en-tête = aucun) print (df.tail ())
y = df.iloc[0:100, 4].valeurs
y = np.where (y == 'Iris-setosa', -1, 1)
X = df.iloc[0:100, 0:4].valeurs
plt.scatter (X[:50, 0], X[:50, 2], couleur = 'rouge', marqueur = 'o', label = 'setosa')plt.scatter (X[50:100, 0], X[50:100, 2], couleur = 'bleu', marqueur = 'x', étiquette = 'versicolor')plt.xlabel ('longueur des sépales (cm)')
plt.ylabel ('longueur du pétale (cm)')
plt.legend (loc = 'en haut à gauche')
plt.show ()

Formation, test et évaluation

X_train, X_test, y_train, y_test = train_test_split (X, y, test_size = 0.2, random_state = 21, stratify = y)
ppn = Perceptron ()
ppn.fit (X_train, y_train)
y_pred = ppn.predict (X_test)
exactitude = 100 * np.sum (y_pred == y_test) / len (y_test)
print ("précision du modèle: =" + str (précision))

En résumé, nous avons montré comment un modèle de base de perceptron peut être construit en python en utilisant la méthode des moindres carrés pour calculer les poids qui sont ensuite utilisés pour calculer la fonction d'activation. Le modèle Perceptron est la pierre angulaire des systèmes de réseaux de neurones plus avancés. Chaque débutant dans le domaine de l'apprentissage en profondeur et de l'intelligence artificielle doit maîtriser les bases du modèle de perceptron.

Le code et le jeu de données de cet article peuvent être téléchargés à partir de ce référentiel github: https://github.com/bot13956/perceptron_classifier.

Show More

SupportIvy

SupportIvy.com : Un lieu pour partager le savoir et mieux comprendre le monde. Meilleure plate-forme de support gratuit pour vous, Documentation &Tutoriels par les experts.

Related Articles

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Close
Close