CNTK - model regresji

Tutaj zajmiemy się mierzeniem wydajności w odniesieniu do modelu regresji.

Podstawy walidacji modelu regresji

Jak wiemy, modele regresji różnią się od modeli klasyfikacyjnych, w tym sensie, że nie ma binarnej miary dobra lub zła dla próbek indywidualnych. W modelach regresji chcemy zmierzyć, jak blisko jest prognozowana wartość. Im bliżej wartości prognozy do oczekiwanego wyniku, tym lepsza wydajność modelu.

Tutaj będziemy mierzyć wydajność NN używanej do regresji przy użyciu różnych funkcji współczynnika błędów.

Obliczanie marginesu błędu

Jak wspomniano wcześniej, podczas walidacji modelu regresji nie możemy powiedzieć, czy prognoza jest dobra, czy zła. Chcemy, aby nasza prognoza była jak najbliższa rzeczywistej wartości. Ale tutaj dopuszczalny jest mały margines błędu.

Wzór na obliczenie marginesu błędu jest następujący -

Tutaj,

Predicted value = wskazany przez kapelusz

Real value = przewidywane przez y

Najpierw musimy obliczyć odległość między wartością przewidywaną a rzeczywistą. Następnie, aby uzyskać ogólny poziom błędu, musimy zsumować te kwadraty odległości i obliczyć średnią. Nazywa się tomean squared funkcja błędu.

Ale jeśli zależy nam na danych dotyczących wydajności, które wyrażają margines błędu, potrzebujemy wzoru, który wyraża bezwzględny błąd. Wzór namean absolute funkcja błędu jest następująca -

Powyższy wzór przyjmuje bezwzględną odległość między wartością przewidywaną a rzeczywistą.

Używanie CNTK do pomiaru wydajności regresji

Tutaj przyjrzymy się, jak używać różnych wskaźników, omówiliśmy w połączeniu z CNTK. Użyjemy modelu regresji, który przewiduje liczbę kilometrów na galon dla samochodów, korzystając z poniższych kroków.

Etapy wdrażania -

Step 1 - Najpierw musimy zaimportować wymagane komponenty z cntk pakiet w następujący sposób -

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

Step 2 - Następnie musimy zdefiniować domyślną funkcję aktywacji za pomocą default_optionsFunkcje. Następnie utwórz nowy zestaw warstw sekwencyjnych i zapewnij dwie warstwy Gęste po 64 neurony każda. Następnie dodajemy dodatkową gęstą warstwę (która będzie działać jako warstwa wyjściowa) do zestawu warstw sekwencyjnych i dajemy 1 neuron bez aktywacji w następujący sposób -

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

Step 3- Po utworzeniu sieci musimy utworzyć funkcję wejściową. Musimy się upewnić, że ma taki sam kształt, jak funkcje, których będziemy używać do treningu.

features = input_variable(X.shape[1])

Step 4 - Teraz musimy stworzyć kolejny input_variable o rozmiarze 1. Będzie używany do przechowywania oczekiwanej wartości NN.

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

Teraz musimy wytrenować model iw tym celu podzielimy zbiór danych i przeprowadzimy wstępne przetwarzanie, korzystając z następujących kroków implementacji -

Step 5−Po pierwsze, zaimportuj StandardScaler ze sklearn.preprocessing, aby uzyskać wartości z zakresu od -1 do +1. Pomoże nam to w zapobieganiu eksplodującym problemom z gradientem w NN.

from sklearn.preprocessing import StandardScalar

Step 6 - Następnie zaimportuj train_test_split ze sklearn.model_selection w następujący sposób -

from sklearn.model_selection import train_test_split

Step 7 - Upuść mpg kolumna z zestawu danych przy użyciu dropmetoda. Na koniec podziel zestaw danych na zestaw uczący i walidacyjny przy użyciutrain_test_split działają w następujący sposób -

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 - Teraz musimy utworzyć kolejną zmienną input_varia o rozmiarze 1. Będzie ona używana do przechowywania oczekiwanej wartości dla NN.

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

Podzieliliśmy i wstępnie przetworzyliśmy dane, teraz musimy przeszkolić NN. Podobnie jak w poprzednich rozdziałach podczas tworzenia modelu regresji, musimy zdefiniować kombinację straty imetric funkcję wytrenowania modelu.

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

Przyjrzyjmy się teraz, jak używać wytrenowanego modelu. W naszym modelu użyjemy kryterium_factory jako kombinacji strat i metryki.

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)

Kompletny przykład wdrożenia

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)

Wynik

-------------------------------------------------------------------
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
[………]

Aby zweryfikować nasz model regresji, musimy upewnić się, że model obsługuje nowe dane tak samo dobrze, jak robi to z danymi uczącymi. W tym celu musimy wywołaćtest metoda włączona loss i metric połączenie z danymi testowymi w następujący sposób -

loss.test([X_test, y_test])

Wyjście -

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