CNTK - Treinamento da Rede Neural

Aqui, vamos entender sobre o treinamento da Rede Neural em CNTK.

Treinando um modelo em CNTK

Na seção anterior, definimos todos os componentes do modelo de aprendizado profundo. Agora é hora de treiná-lo. Como discutimos anteriormente, podemos treinar um modelo NN em CNTK usando a combinação delearner e trainer.

Escolher um aluno e configurar o treinamento

Nesta seção, iremos definir o learner. CNTK fornece várioslearnersescolher a partir de. Para nosso modelo, definido nas seções anteriores, estaremos usandoStochastic Gradient Descent (SGD) learner.

Para treinar a rede neural, vamos configurar o learner e trainer com a ajuda das seguintes etapas -

Step 1 - Primeiro, precisamos importar sgd função de cntk.lerners pacote.

from cntk.learners import sgd

Step 2 - Em seguida, precisamos importar Trainer função de cntk.trainpacote .trainer.

from cntk.train.trainer import Trainer

Step 3 - Agora, precisamos criar um learner. Pode ser criado invocandosgd função junto com o fornecimento de parâmetros do modelo e um valor para a taxa de aprendizagem.

learner = sgd(z.parametrs, 0.01)

Step 4 - Por fim, precisamos inicializar o trainer. Deve ser fornecida a rede, a combinação doloss e metric juntamente com o learner.

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

A taxa de aprendizagem que controla a velocidade da otimização deve ser um pequeno número entre 0,1 e 0,001.

Escolhendo um aluno e configurando o treinamento - Exemplo completo

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

Alimentando dados para o treinador

Depois de escolher e configurar o treinador, é hora de carregar o conjunto de dados. Nós salvamos oiris conjunto de dados como um.CSV arquivo e usaremos o pacote de wrangling de dados chamado pandas para carregar o conjunto de dados.

Etapas para carregar o conjunto de dados do arquivo .CSV

Step 1 - Primeiro, precisamos importar o pandas pacote.

from import pandas as pd

Step 2 - Agora, precisamos invocar a função chamada read_csv função para carregar o arquivo .csv do disco.

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

Depois de carregar o conjunto de dados, precisamos dividi-lo em um conjunto de recursos e um rótulo.

Etapas para dividir o conjunto de dados em recursos e rótulo

Step 1- Primeiro, precisamos selecionar todas as linhas e as primeiras quatro colunas do conjunto de dados. Isso pode ser feito usandoiloc função.

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

Step 2- Em seguida, precisamos selecionar a coluna de espécies do conjunto de dados da íris. Estaremos usando a propriedade values para acessar o subjacentenumpy array.

x = df_source[‘species’].values

Etapas para codificar a coluna de espécies em uma representação vetorial numérica

Como discutimos anteriormente, nosso modelo é baseado na classificação, requer valores de entrada numéricos. Portanto, aqui precisamos codificar a coluna de espécies em uma representação vetorial numérica. Vamos ver as etapas para fazer isso -

Step 1- Primeiro, precisamos criar uma expressão de lista para iterar sobre todos os elementos do array. Em seguida, execute uma pesquisa no dicionário label_mapping para cada valor.

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

Step 2- Em seguida, converta este valor numérico convertido em um vetor codificado de um ponto. Estaremos usandoone_hot funcionar da seguinte forma -

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

Step 3 - Por fim, precisamos transformar essa lista convertida em um numpy array.

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

Etapas para detectar overfitting

A situação, quando seu modelo lembra das amostras, mas não pode deduzir regras das amostras de treinamento, é overfitting. Com a ajuda das etapas a seguir, podemos detectar overfitting em nosso modelo -

Step 1 - Primeiro, de sklearn pacote, importe o train_test_split função do model_selection módulo.

from sklearn.model_selection import train_test_split

Step 2 - Em seguida, precisamos invocar a função train_test_split com os recursos xe rótulos y da seguinte forma -

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

Especificamos um test_size de 0,2 para reservar 20% dos dados totais.

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

Etapas para alimentar o conjunto de treinamento e o conjunto de validação para nosso modelo

Step 1 - Para treinar nosso modelo, primeiro, vamos invocar o train_minibatchmétodo. Em seguida, forneça um dicionário que mapeie os dados de entrada para a variável de entrada que usamos para definir o NN e sua função de perda associada.

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

Step 2 - Em seguida, ligue train_minibatch usando o seguinte for loop -

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))

Alimentando dados para o treinador - exemplo completo

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))

Medindo o desempenho de NN

Para otimizar nosso modelo NN, sempre que passamos dados pelo treinador, ele mede o desempenho do modelo por meio da métrica que configuramos para o treinador. Tal medida de desempenho do modelo NN durante o treinamento é nos dados de treinamento. Mas, por outro lado, para uma análise completa do desempenho do modelo, precisamos usar dados de teste também.

Portanto, para medir o desempenho do modelo usando os dados de teste, podemos invocar o test_minibatch método no trainer como segue -

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

Fazendo previsão com NN

Depois de treinar um modelo de aprendizado profundo, o mais importante é fazer previsões usando isso. Para fazer a previsão do NN treinado acima, podemos seguir os passos dados−

Step 1 - Primeiro, precisamos escolher um item aleatório do conjunto de teste usando a seguinte função -

np.random.choice

Step 2 - Em seguida, precisamos selecionar os dados de amostra do conjunto de teste usando sample_index.

Step 3 - Agora, para converter a saída numérica para o NN em um rótulo real, crie um mapeamento invertido.

Step 4 - Agora, use o selecionado sampledados. Faça uma previsão invocando o NN z como uma função.

Step 5- Agora, uma vez que você obteve a saída prevista, pegue o índice do neurônio que tem o valor mais alto como o valor previsto. Isso pode ser feito usando onp.argmax função do numpy pacote.

Step 6 - Por último, converta o valor do índice no rótulo real usando inverted_mapping.

Fazendo previsões com NN - exemplo completo

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)

Resultado

Depois de treinar o modelo de aprendizado profundo acima e executá-lo, você obterá o seguinte resultado -

Iris-versicolor