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 sgdStep 2 - Em seguida, precisamos importar Trainer função de cntk.trainpacote .trainer.
from cntk.train.trainer import TrainerStep 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 pdStep 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].valuesStep 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’].valuesEtapas 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 resultStep 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_splitStep 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.choiceStep 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