CNTK - Modelo de Regressão

Aqui, estudaremos sobre como medir o desempenho em relação a um modelo de regressão.

Noções básicas de validação de um modelo de regressão

Como sabemos que os modelos de regressão são diferentes dos modelos de classificação, no sentido de que não existe uma medida binária de certo ou errado para as amostras dos indivíduos. Em modelos de regressão, queremos medir o quão próxima a previsão está do valor real. Quanto mais próximo o valor da previsão estiver da saída esperada, melhor será o desempenho do modelo.

Aqui, vamos medir o desempenho do NN usado para regressão usando diferentes funções de taxa de erro.

Calculando margem de erro

Conforme discutido anteriormente, ao validar um modelo de regressão, não podemos dizer se uma previsão está certa ou errada. Queremos que nossa previsão seja o mais próximo possível do valor real. Mas, uma pequena margem de erro é aceitável aqui.

A fórmula para calcular a margem de erro é a seguinte -

Aqui,

Predicted value = indicado por um chapéu

Real value = previsto por y

Primeiro, precisamos calcular a distância entre o valor previsto e o valor real. Então, para obter uma taxa de erro geral, precisamos somar essas distâncias quadradas e calcular a média. Isso é chamado demean squared função de erro.

Mas, se quisermos números de desempenho que expressem uma margem de erro, precisamos de uma fórmula que expresse o erro absoluto. A fórmula paramean absolute a função de erro é a seguinte -

A fórmula acima considera a distância absoluta entre o valor predito e o valor real.

Usando CNTK para medir o desempenho de regressão

Aqui, veremos como usar as diferentes métricas que discutimos em combinação com o CNTK. Usaremos um modelo de regressão, que prevê milhas por galão para carros usando as etapas fornecidas abaixo.

Etapas de implementação -

Step 1 - Primeiro, precisamos importar os componentes necessários do cntk pacote da seguinte forma -

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

Step 2 - Em seguida, precisamos definir uma função de ativação padrão usando o default_optionsfunções. Em seguida, crie um novo conjunto de camadas sequenciais e forneça duas camadas densas com 64 neurônios cada. Em seguida, adicionamos uma camada Densa adicional (que atuará como a camada de saída) ao conjunto de camadas Sequencial e fornecemos 1 neurônio sem uma ativação da seguinte maneira -

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

Step 3- Uma vez que a rede foi criada, precisamos criar um recurso de entrada. Precisamos ter certeza de que tem o mesmo formato que os recursos que usaremos para o treinamento.

features = input_variable(X.shape[1])

Step 4 - Agora, precisamos criar outro input_variable com tamanho 1. Será usado para armazenar o valor esperado para NN.

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

Agora, precisamos treinar o modelo e, para isso, vamos dividir o conjunto de dados e realizar o pré-processamento usando as seguintes etapas de implementação -

Step 5−Primeiro, importe StandardScaler de sklearn.preprocessing para obter os valores entre -1 e +1. Isso nos ajudará contra a explosão de problemas de gradiente no NN.

from sklearn.preprocessing import StandardScalar

Step 6 - Em seguida, importe train_test_split de sklearn.model_selection da seguinte maneira−

from sklearn.model_selection import train_test_split

Step 7 - Largue o mpg coluna do conjunto de dados usando o dropmétodo. Por fim, divida o conjunto de dados em um conjunto de treinamento e validação usando otrain_test_split funcionar da seguinte forma -

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 - Agora, precisamos criar outra input_variable com tamanho 1. Ela será usada para armazenar o valor esperado para NN.

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

Dividimos e pré-processamos os dados, agora precisamos treinar o NN. Como fizemos nas seções anteriores durante a criação do modelo de regressão, precisamos definir uma combinação de uma perda emetric função para treinar o modelo.

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

Agora, vamos dar uma olhada em como usar o modelo treinado. Para nosso modelo, usaremos criterion_factory como a combinação de perda e métrica.

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)

Exemplo de implementação completo

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)

Resultado

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

Para validar nosso modelo de regressão, precisamos ter certeza de que o modelo lida com novos dados tão bem quanto com os dados de treinamento. Para isso, precisamos invocar otest método em loss e metric combinação com dados de teste da seguinte forma -

loss.test([X_test, y_test])

Output−

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