CNTK - Modèle de régression

Ici, nous allons étudier la mesure de la performance par rapport à un modèle de régression.

Bases de la validation d'un modèle de régression

Comme nous savons que les modèles de régression sont différents des modèles de classification, en ce sens qu'il n'y a pas de mesure binaire du bien ou du mal pour les échantillons d'individus. Dans les modèles de régression, nous voulons mesurer à quel point la prédiction est proche de la valeur réelle. Plus la valeur de prédiction est proche de la sortie attendue, meilleures sont les performances du modèle.

Ici, nous allons mesurer les performances de NN utilisé pour la régression en utilisant différentes fonctions de taux d'erreur.

Calcul de la marge d'erreur

Comme indiqué précédemment, lors de la validation d'un modèle de régression, nous ne pouvons pas dire si une prédiction est bonne ou mauvaise. Nous voulons que notre prédiction soit aussi proche que possible de la valeur réelle. Mais, une petite marge d'erreur est acceptable ici.

La formule de calcul de la marge d'erreur est la suivante -

Ici,

Predicted value = indiqué y par un chapeau

Real value = prédit par y

Tout d'abord, nous devons calculer la distance entre la valeur prévue et la valeur réelle. Ensuite, pour obtenir un taux d'erreur global, nous devons additionner ces distances au carré et calculer la moyenne. C'est ce qu'on appelle lemean squared fonction d'erreur.

Mais, si nous voulons des chiffres de performance qui expriment une marge d'erreur, nous avons besoin d'une formule qui exprime l'erreur absolue. La formule pourmean absolute la fonction d'erreur est la suivante -

La formule ci-dessus prend la distance absolue entre la valeur prévue et la valeur réelle.

Utilisation de CNTK pour mesurer les performances de régression

Ici, nous verrons comment utiliser les différentes métriques, dont nous avons discuté en combinaison avec CNTK. Nous utiliserons un modèle de régression, qui prédit les miles par gallon pour les voitures en suivant les étapes ci-dessous.

Étapes de mise en œuvre -

Step 1 - Tout d'abord, nous devons importer les composants requis depuis cntk paquet comme suit -

from cntk import default_option, input_variable
from cntk.layers import Dense, Sequential
from cntk.ops import relu

Step 2 - Ensuite, nous devons définir une fonction d'activation par défaut à l'aide du default_optionsles fonctions. Ensuite, créez un nouvel ensemble de couches séquentielles et fournissez deux couches denses de 64 neurones chacune. Ensuite, nous ajoutons une couche Dense supplémentaire (qui agira comme couche de sortie) à l'ensemble de couches séquentielles et donnons 1 neurone sans activation comme suit -

with default_options(activation=relu):
model = Sequential([Dense(64),Dense(64),Dense(1,activation=None)])

Step 3- Une fois le réseau créé, nous devons créer une fonction d'entrée. Nous devons nous assurer qu'il a la même forme que les fonctionnalités que nous allons utiliser pour la formation.

features = input_variable(X.shape[1])

Step 4 - Maintenant, nous devons créer un autre input_variable avec la taille 1. Il sera utilisé pour stocker la valeur attendue pour NN.

target = input_variable(1)
z = model(features)

Maintenant, nous devons former le modèle et pour ce faire, nous allons diviser l'ensemble de données et effectuer un prétraitement en utilisant les étapes de mise en œuvre suivantes -

Step 5−Tout d'abord, importez StandardScaler depuis sklearn.preprocessing pour obtenir les valeurs comprises entre -1 et +1. Cela nous aidera à éviter l'explosion des problèmes de gradient dans le NN.

from sklearn.preprocessing import StandardScalar

Step 6 - Ensuite, importez train_test_split depuis sklearn.model_selection comme suit -

from sklearn.model_selection import train_test_split

Step 7 - Lâchez le mpg colonne de l'ensemble de données à l'aide de la dropméthode. Enfin, divisez l'ensemble de données en un ensemble d'apprentissage et de validation à l'aide dutrain_test_split fonction comme suit -

x = df_cars.drop(columns=[‘mpg’]).values.astype(np.float32)
y=df_cars.iloc[: , 0].values.reshape(-1, 1).astype(np.float32)
scaler = StandardScaler()
X = scaler.fit_transform(x)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

Step 8 - Maintenant, nous devons créer une autre variable_entrée de taille 1. Elle sera utilisée pour stocker la valeur attendue pour NN.

target = input_variable(1)
z = model(features)

Nous avons divisé et prétraité les données, nous devons maintenant former le NN. Comme dans les sections précédentes lors de la création du modèle de régression, nous devons définir une combinaison d'une perte etmetric fonction pour entraîner le modèle.

import cntk
def absolute_error(output, target):
   return cntk.ops.reduce_mean(cntk.ops.abs(output – target))
@ cntk.Function
def criterion_factory(output, target):
   loss = squared_error(output, target)
   metric = absolute_error(output, target)
   return loss, metric

Voyons maintenant comment utiliser le modèle entraîné. Pour notre modèle, nous utiliserons critère_factory comme combinaison de perte et de métrique.

from cntk.losses import squared_error
from cntk.learners import sgd
from cntk.logging import ProgressPrinter
progress_printer = ProgressPrinter(0)
loss = criterion_factory (z, target)
learner = sgd(z.parameters, 0.001)
training_summary=loss.train((x_train,y_train),parameter_learners=[learner],callbacks=[progress_printer],minibatch_size=16,max_epochs=10)

Exemple d'implémentation complet

from cntk import default_option, input_variable
from cntk.layers import Dense, Sequential
from cntk.ops import relu
with default_options(activation=relu):
model = Sequential([Dense(64),Dense(64),Dense(1,activation=None)])
features = input_variable(X.shape[1])
target = input_variable(1)
z = model(features)
from sklearn.preprocessing import StandardScalar
from sklearn.model_selection import train_test_split
x = df_cars.drop(columns=[‘mpg’]).values.astype(np.float32)
y=df_cars.iloc[: , 0].values.reshape(-1, 1).astype(np.float32)
scaler = StandardScaler()
X = scaler.fit_transform(x)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
target = input_variable(1)
z = model(features)
import cntk
def absolute_error(output, target):
   return cntk.ops.reduce_mean(cntk.ops.abs(output – target))
@ cntk.Function
def criterion_factory(output, target):
loss = squared_error(output, target)
metric = absolute_error(output, target)
return loss, metric
from cntk.losses import squared_error
from cntk.learners import sgd
from cntk.logging import ProgressPrinter
progress_printer = ProgressPrinter(0)
loss = criterion_factory (z, target)
learner = sgd(z.parameters, 0.001)
training_summary=loss.train((x_train,y_train),parameter_learners=[learner],callbacks=[progress_printer],minibatch_size=16,max_epochs=10)

Production

-------------------------------------------------------------------
average  since   average   since  examples
loss     last    metric    last
------------------------------------------------------
Learning rate per minibatch: 0.001
690       690     24.9     24.9       16
654       636     24.1     23.7       48
[………]

Afin de valider notre modèle de régression, nous devons nous assurer que le modèle gère les nouvelles données aussi bien qu'il le fait avec les données d'entraînement. Pour cela, nous devons invoquer letest méthode sur loss et metric combinaison avec les données d'essai comme suit -

loss.test([X_test, y_test])

Sortie−

{'metric': 1.89679785619, 'samples': 79}