Olá Habitantes! O aprendizado profundo tornou-se um mecanismo poderoso para trabalhar com inteligência artificial. Ilustrações vívidas e exemplos simples de código o pouparão da necessidade de se aprofundar nos aspectos complexos da construção de modelos de aprendizado profundo, tornando as tarefas complexas acessíveis e divertidas.
John Krohn, Grant Beyleveld e o grande ilustrador Aglae Bassens usam exemplos e analogias vívidas para explicar o que é o aprendizado profundo, por que é tão popular e como se relaciona com outras abordagens ao aprendizado de máquina. O livro é ideal para desenvolvedores, cientistas de dados, pesquisadores, analistas e programadores aspirantes que desejam aplicar aprendizado profundo ao seu trabalho. Os cálculos teóricos são perfeitamente complementados pelo código do aplicativo em Python nos notebooks Jupyter. Você aprenderá técnicas para criar modelos eficientes no TensorFlow e Keras e também se familiarizará com o PyTorch.
O conhecimento básico do aprendizado profundo permitirá que você construa aplicativos do mundo real, desde a visão computacional e processamento de linguagem natural até a geração de imagens e algoritmos de jogos.
Rede intermediária de profundidade Keras
No final deste capítulo, traduziremos o novo conhecimento teórico na rede neural e veremos se podemos superar o modelo shallow_net_in_keras.ipynb anterior na classificação de números manuscritos.
Os primeiros estágios de criação de uma rede de profundidade intermediária no notebook Jupyter intermediário_net_em_keras.ipynb são idênticos aos estágios de criação de seu antecessor - uma rede rasa. Primeiro, as mesmas dependências Keras são carregadas e o conjunto de dados MNIST é inserido e processado da mesma maneira. Como você pode ver na Listagem 8.1, a diversão começa onde a arquitetura de rede neural é definida.
Listagem 8.1. Código que define a arquitetura de rede neural com profundidade intermediária
model = Sequential()
model.add(Dense(64, activation='relu', input_shape=(784,)))
model.add(Dense(64, activation='relu'))
model.add(Dense(10, activation='softmax'))A primeira linha desse fragmento de código, model = Sequential (), é a mesma da rede anterior (Listagem 5.6); é uma instância de um objeto de modelo de rede neural. As discrepâncias começam na próxima linha. Nele, substituímos a função de ativação sigmóide na primeira camada oculta pela função relu, conforme recomendado no Capítulo 6. Todos os outros parâmetros da primeira camada, exceto a função de ativação, permaneceram os mesmos: ainda é composto por 64 neurônios e a dimensão da camada de entrada permanece a mesma - 784 neurônios.
Outra mudança significativa na Listagem 8.1 sobre a arquitetura superficial na Listagem 5.6 é a presença de uma segunda camada oculta de neurônios artificiais. Ao chamar model.add (), adicionamos sem esforço uma segunda camada densa com 64 neurônios relu, justificando a palavra intermediária no nome do notebook. Ao chamar model.summary (), você pode ver como mostra a Fig. 8.9 que essa camada adicional adiciona 4.160 parâmetros de treinamento adicionais, em comparação com a arquitetura superficial (veja a Figura 7.5). Os parâmetros podem ser divididos em:
- 4096 pesos correspondentes às conexões de cada um dos 64 neurônios na segunda camada oculta com cada um dos 64 neurônios na primeira camada oculta (64 × 64 = 4096);
- mais 64 compensações, uma para cada neurônio na segunda camada oculta;
- o resultado são 4160 parâmetros: n parameters = nw + nb = 4096 + 64 =
= 4160.
Além das mudanças na arquitetura do modelo, também alteramos as opções de compilação para o modelo, conforme mostrado na Listagem 8.2.
Listagem 8.2. Código intermediário de compilação de redes neurais de profundidade
model.compile(loss='categorical_crossentropy',
optimizer=SGD(lr=0.1),
metrics=['accuracy'])
Essas linhas são da Listagem 8.2:
- definir uma função de custo com base na entropia cruzada: loss = 'categorical_crossentropy' (em uma rede rasa, o custo quadrático foi usado loss = 'mean_squared_error');
- defina um método de descida de gradiente estocástico para minimizar o custo: otimizador = SGD;
- defina o hiperparâmetro da taxa de aprendizado: lr = 0,1 (1) ;
- , , Keras , : metrics=['accuracy'](2).
(1) , , .
(2) , , , , , . , , , . , , : , (, « 86 »), (« 86 , »).
Por fim, treinamos a rede intermediária executando o código na Listagem 8.3.
Listagem 8.3. Código intermediário de treinamento em redes neurais de profundidade
model.fit(X_train, y_train,
batch_size=128, epochs=20,
verbose=1,
validation_data=(X_valid, y_valid))A única mudança no treinamento da rede intermediária na rede rasa (consulte a Listagem 5.7) é que as épocas de hiperparâmetros foram reduzidas em uma ordem de magnitude de 200 para 20. Como você verá mais adiante, uma arquitetura de middleware mais eficiente requer muito menos épocas para treinar.
Na fig. 8.10 apresenta os resultados das quatro primeiras épocas do aprendizado em rede. Como você deve se lembrar, nossa arquitetura superficial alcançou um platô de 86% de precisão nos dados de validação após 200 épocas. A rede de profundidade intermediária a superou significativamente: como mostra o campo val_acc, a rede alcançou 92,34% de precisão após a primeira época de treinamento. Após a terceira época, a precisão excedeu 95% e, até a 20ª, parece ter atingido um platô de cerca de 97,6%. Fizemos progressos sérios!
Vamos examinar com mais detalhes a saída de model.fit (), mostrada na Fig. 8.10:
- O indicador de processo mostrado abaixo é preenchido durante 469 “ciclos de treinamento” (consulte a Fig. 8.5):
60000/60000 [========================= ======] - 1s 15us/step , 469 1 , 15 .
- loss . 0.4744 (SGD) , 0.0332 .
- acc — . 86.37% 99% . , .
- , (val_loss), , 0.08 .
- (val_acc). , 97.6%, 86% .
Neste capítulo, fizemos um ótimo trabalho. Primeiro, aprendemos como uma rede neural de parâmetro fixo processa informações. Em seguida, descobrimos os métodos de interação - funções de custo, descida gradiente estocástica e retropropagação - que permitem ajustar os parâmetros da rede para aproximar qualquer valor y verdadeiro que tenha um relacionamento contínuo com alguma entrada x. Ao longo do caminho, nos familiarizamos com vários hiperparâmetros, incluindo a velocidade de aprendizado, o tamanho da embalagem e o número de eras de treinamento, bem como as regras práticas para definir cada uma delas. No final do capítulo, aplicamos nosso novo conhecimento para criar uma rede neural de profundidade intermediária que superou significativamente a rede superficial anterior no mesmo problema de classificação de dígitos manuscritos.Em seguida, nos familiarizaremos com os métodos para melhorar a estabilidade das redes neurais artificiais à medida que elas se aprofundam, o que nos permitirá desenvolver e treinar um modelo de aprendizado profundo de pleno direito.
»Mais detalhes sobre o livro podem ser encontrados no site da editora
» Sumário
» Trecho
Para Habitantes, um desconto de 25% no cupom - Deep Learning
Após o pagamento pela versão impressa do livro, um e-livro é enviado para o e-mail.