CNTK - Formation du réseau neuronal

Ici, nous allons comprendre la formation du réseau neuronal dans CNTK.

Formation d'un modèle en CNTK

Dans la section précédente, nous avons défini tous les composants du modèle d'apprentissage en profondeur. Il est maintenant temps de le former. Comme nous l'avons vu précédemment, nous pouvons entraîner un modèle NN dans CNTK en utilisant la combinaison delearner et trainer.

Choisir un apprenant et mettre en place une formation

Dans cette section, nous définirons le learner. CNTK fournit plusieurslearnersà choisir. Pour notre modèle, défini dans les sections précédentes, nous utiliseronsStochastic Gradient Descent (SGD) learner.

Afin de former le réseau de neurones, configurons le learner et trainer à l'aide des étapes suivantes -

Step 1 - Tout d'abord, nous devons importer sgd fonction de cntk.lerners paquet.

from cntk.learners import sgd

Step 2 - Ensuite, nous devons importer Trainer fonction de cntk.trainPaquet .trainer.

from cntk.train.trainer import Trainer

Step 3 - Maintenant, nous devons créer un learner. Il peut être créé en invoquantsgd fonction en plus de fournir les paramètres du modèle et une valeur pour le taux d'apprentissage.

learner = sgd(z.parametrs, 0.01)

Step 4 - Enfin, nous devons initialiser le trainer. Il faut prévoir le réseau, la combinaison desloss et metric avec le learner.

trainer = Trainer(z, (loss, error_rate), [learner])

Le taux d'apprentissage qui contrôle la vitesse d'optimisation doit être un petit nombre entre 0,1 et 0,001.

Choix d'un apprenant et mise en place de la formation - Exemple complet

from cntk.learners import sgd
from cntk.train.trainer import Trainer
learner = sgd(z.parametrs, 0.01)
trainer = Trainer(z, (loss, error_rate), [learner])

Alimentation des données dans le formateur

Une fois que nous avons choisi et configuré le formateur, il est temps de charger l'ensemble de données. Nous avons sauvé leiris ensemble de données en tant que fichier.CSV fichier et nous utiliserons le package de gestion de données nommé pandas pour charger l'ensemble de données.

Étapes pour charger l'ensemble de données à partir du fichier .CSV

Step 1 - Tout d'abord, nous devons importer le pandas paquet.

from import pandas as pd

Step 2 - Maintenant, nous devons invoquer la fonction nommée read_csv pour charger le fichier .csv à partir du disque.

df_source = pd.read_csv(‘iris.csv’, names = [‘sepal_length’, ‘sepal_width’, 
‘petal_length’, ‘petal_width’, index_col=False)

Une fois que nous avons chargé l'ensemble de données, nous devons le diviser en un ensemble d'entités et une étiquette.

Étapes pour diviser le jeu de données en entités et en étiquettes

Step 1- Tout d'abord, nous devons sélectionner toutes les lignes et les quatre premières colonnes de l'ensemble de données. Cela peut être fait en utilisantiloc fonction.

x = df_source.iloc[:, :4].values

Step 2- Ensuite, nous devons sélectionner la colonne des espèces dans l'ensemble de données iris. Nous utiliserons la propriété values ​​pour accéder au sous-jacentnumpy tableau.

x = df_source[‘species’].values

Étapes pour coder la colonne des espèces en une représentation vectorielle numérique

Comme nous l'avons vu précédemment, notre modèle est basé sur la classification, il nécessite des valeurs d'entrée numériques. Par conséquent, nous devons ici coder la colonne des espèces en une représentation vectorielle numérique. Voyons les étapes pour le faire -

Step 1- Tout d'abord, nous devons créer une expression de liste pour itérer sur tous les éléments du tableau. Ensuite, effectuez une recherche dans le dictionnaire label_mapping pour chaque valeur.

label_mapping = {‘Iris-Setosa’ : 0, ‘Iris-Versicolor’ : 1, ‘Iris-Virginica’ : 2}

Step 2- Ensuite, convertissez cette valeur numérique convertie en un vecteur encodé à chaud. Nous utiliseronsone_hot fonction comme suit -

def one_hot(index, length):
result = np.zeros(length)
result[index] = 1
return result

Step 3 - Enfin, nous devons transformer cette liste convertie en un numpy tableau.

y = np.array([one_hot(label_mapping[v], 3) for v in y])

Étapes pour détecter le surajustement

La situation, lorsque votre modèle se souvient des échantillons mais ne peut pas déduire de règles à partir des échantillons d'apprentissage, est surajustement. À l'aide des étapes suivantes, nous pouvons détecter le surajustement sur notre modèle -

Step 1 - D'abord, de sklearn package, importez le train_test_split fonction de la model_selection module.

from sklearn.model_selection import train_test_split

Step 2 - Ensuite, nous devons invoquer la fonction train_test_split avec les caractéristiques x et les étiquettes y comme suit -

x_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0-2, 
stratify=y)

Nous avons spécifié un test_size de 0,2 pour mettre de côté 20% du total des données.

label_mapping = {‘Iris-Setosa’ : 0, ‘Iris-Versicolor’ : 1, ‘Iris-Virginica’ : 2}

Étapes pour alimenter l'ensemble de formation et l'ensemble de validation dans notre modèle

Step 1 - Afin de former notre modèle, nous allons d'abord invoquer le train_minibatchméthode. Ensuite, donnez-lui un dictionnaire qui mappe les données d'entrée à la variable d'entrée que nous avons utilisée pour définir le NN et sa fonction de perte associée.

trainer.train_minibatch({ features: X_train, label: y_train})

Step 2 - Ensuite, appelez train_minibatch en utilisant la boucle for suivante -

for _epoch in range(10):
trainer.train_minbatch ({ feature: X_train, label: y_train})
print(‘Loss: {}, Acc: {}’.format(
trainer.previous_minibatch_loss_average,
trainer.previous_minibatch_evaluation_average))

Introduire des données dans le formateur - Exemple complet

from import pandas as pd
df_source = pd.read_csv(‘iris.csv’, names = [‘sepal_length’, ‘sepal_width’, ‘petal_length’, ‘petal_width’, index_col=False)
x = df_source.iloc[:, :4].values
x = df_source[‘species’].values
label_mapping = {‘Iris-Setosa’ : 0, ‘Iris-Versicolor’ : 1, ‘Iris-Virginica’ : 2}
def one_hot(index, length):
result = np.zeros(length)
result[index] = 1
return result
y = np.array([one_hot(label_mapping[v], 3) for v in y])
from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0-2, stratify=y)
label_mapping = {‘Iris-Setosa’ : 0, ‘Iris-Versicolor’ : 1, ‘Iris-Virginica’ : 2}
trainer.train_minibatch({ features: X_train, label: y_train})
for _epoch in range(10):
trainer.train_minbatch ({ feature: X_train, label: y_train})
print(‘Loss: {}, Acc: {}’.format(
trainer.previous_minibatch_loss_average,
trainer.previous_minibatch_evaluation_average))

Mesurer les performances de NN

Afin d'optimiser notre modèle NN, chaque fois que nous transmettons des données via le formateur, il mesure les performances du modèle via la métrique que nous avons configurée pour le formateur. Une telle mesure des performances du modèle NN pendant la formation se fait sur les données de formation. Mais d'un autre côté, pour une analyse complète des performances du modèle, nous devons également utiliser des données de test.

Ainsi, pour mesurer les performances du modèle à l'aide des données de test, nous pouvons appeler le test_minibatch méthode sur le trainer comme suit -

trainer.test_minibatch({ features: X_test, label: y_test})

Faire des prédictions avec NN

Une fois que vous avez formé un modèle d'apprentissage en profondeur, le plus important est de faire des prédictions à l'aide de celui-ci. Afin de faire une prédiction à partir du NN formé ci-dessus, nous pouvons suivre les étapes données -

Step 1 - Tout d'abord, nous devons choisir un élément aléatoire de l'ensemble de test en utilisant la fonction suivante -

np.random.choice

Step 2 - Ensuite, nous devons sélectionner les données d'échantillon de l'ensemble de test en utilisant sample_index.

Step 3 - Maintenant, afin de convertir la sortie numérique vers le NN en une étiquette réelle, créez un mappage inversé.

Step 4 - Maintenant, utilisez le sampleLes données. Faites une prédiction en invoquant le NN z en tant que fonction.

Step 5- Maintenant, une fois que vous avez obtenu la sortie prédite, prenez l'indice du neurone qui a la valeur la plus élevée comme valeur prédite. Cela peut être fait en utilisant lenp.argmax fonction de la numpy paquet.

Step 6 - Enfin, convertissez la valeur d'index en étiquette réelle en utilisant inverted_mapping.

Faire des prédictions avec NN - Exemple complet

sample_index = np.random.choice(X_test.shape[0])
sample = X_test[sample_index]
inverted_mapping = {
   1:’Iris-setosa’,
   2:’Iris-versicolor’,
   3:’Iris-virginica’
}
prediction = z(sample)
predicted_label = inverted_mapping[np.argmax(prediction)]
print(predicted_label)

Production

Après avoir entraîné le modèle d'apprentissage en profondeur ci-dessus et l'avoir exécuté, vous obtiendrez le résultat suivant:

Iris-versicolor