Keras - Guia rápido
Keras - Introdução
O aprendizado profundo é um dos principais subcampos da estrutura de aprendizado de máquina. O aprendizado de máquina é o estudo do projeto de algoritmos, inspirado no modelo do cérebro humano. O aprendizado profundo está se tornando mais popular nos campos da ciência de dados, como robótica, inteligência artificial (IA), reconhecimento de áudio e vídeo e reconhecimento de imagem. A rede neural artificial é o núcleo das metodologias de aprendizado profundo. O aprendizado profundo é suportado por várias bibliotecas, como Theano, TensorFlow, Caffe, Mxnet etc., Keras é uma das bibliotecas python mais poderosas e fáceis de usar, que é construída sobre bibliotecas populares de aprendizado profundo, como TensorFlow, Theano, etc. , para criar modelos de aprendizagem profunda.
Visão geral de Keras
Keras é executado em bibliotecas de máquina de código aberto, como TensorFlow, Theano ou Cognitive Toolkit (CNTK). Theano é uma biblioteca python usada para tarefas de computação numérica rápida. TensorFlow é a biblioteca de matemática simbólica mais famosa usada para criar redes neurais e modelos de aprendizado profundo. O TensorFlow é muito flexível e o principal benefício é a computação distribuída. CNTK é um framework de aprendizado profundo desenvolvido pela Microsoft. Ele usa bibliotecas como Python, C #, C ++ ou kits de ferramentas de aprendizado de máquina autônomo. Theano e TensorFlow são bibliotecas muito poderosas, mas difíceis de entender para a criação de redes neurais.
Keras é baseado em uma estrutura mínima que fornece uma maneira limpa e fácil de criar modelos de aprendizado profundo baseados no TensorFlow ou Theano. Keras foi projetado para definir rapidamente modelos de aprendizado profundo. Bem, Keras é uma escolha ideal para aplicativos de aprendizado profundo.
Características
Keras aproveita várias técnicas de otimização para tornar a API de rede neural de alto nível mais fácil e com melhor desempenho. Suporta os seguintes recursos -
API consistente, simples e extensível.
Estrutura mínima - fácil de obter o resultado sem babados.
Ele oferece suporte a várias plataformas e back-ends.
É uma estrutura amigável que roda em CPU e GPU.
Alta escalabilidade de computação.
Benefícios
Keras é uma estrutura altamente poderosa e dinâmica e apresenta as seguintes vantagens -
Maior apoio da comunidade.
Fácil de testar.
As redes neurais Keras são escritas em Python, o que torna as coisas mais simples.
Keras suporta redes de convolução e recorrentes.
Modelos de aprendizado profundo são componentes discretos, portanto, você pode combinar de várias maneiras.
Keras - Instalação
Este capítulo explica como instalar o Keras em sua máquina. Antes de passar para a instalação, vamos examinar os requisitos básicos do Keras.
Pré-requisitos
Você deve atender aos seguintes requisitos -
- Qualquer tipo de sistema operacional (Windows, Linux ou Mac)
- Python versão 3.5 ou superior.
Pitão
Keras é uma biblioteca de rede neural baseada em python, portanto, o python deve ser instalado em sua máquina. Se o python estiver instalado corretamente em sua máquina, abra seu terminal e digite python, você poderá ver uma resposta semelhante à especificada abaixo,
Python 3.6.5 (v3.6.5:f59c0932b4, Mar 28 2018, 17:00:18)
[MSC v.1900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>
A partir de agora, a versão mais recente é '3.7.2'. Se o Python não estiver instalado, visite o link oficial do python - www.python.org e baixe a versão mais recente com base em seu sistema operacional e instale-a imediatamente em seu sistema.
Etapas de instalação do Keras
A instalação do Keras é bastante fácil. Siga as etapas abaixo para instalar corretamente o Keras em seu sistema.
Etapa 1: Crie um ambiente virtual
Virtualenvé usado para gerenciar pacotes Python para diferentes projetos. Isso será útil para evitar quebrar os pacotes instalados em outros ambientes. Portanto, é sempre recomendável usar um ambiente virtual durante o desenvolvimento de aplicativos Python.
Linux/Mac OS
Usuários de Linux ou mac OS, vão para o diretório raiz do seu projeto e digite o comando abaixo para criar um ambiente virtual,
python3 -m venv kerasenv
Depois de executar o comando acima, o diretório “kerasenv” é criado com bin,lib and include folders em seu local de instalação.
Windows
O usuário do Windows pode usar o comando abaixo,
py -m venv keras
Etapa 2: ativar o ambiente
Esta etapa configurará os executáveis python e pip no caminho do shell.
Linux/Mac OS
Agora criamos um ambiente virtual chamado “kerasvenv”. Mova para a pasta e digite o comando abaixo,
$ cd kerasvenv kerasvenv $ source bin/activate
Windows
Os usuários do Windows movem-se para dentro da pasta “kerasenv” e digitam o comando abaixo,
.\env\Scripts\activate
Etapa 3: bibliotecas Python
Keras depende das seguintes bibliotecas Python.
- Numpy
- Pandas
- Scikit-learn
- Matplotlib
- Scipy
- Seaborn
Felizmente, você instalou todas as bibliotecas acima em seu sistema. Se essas bibliotecas não estiverem instaladas, use o comando abaixo para instalar uma por uma.
numpy
pip install numpy
você pode ver a seguinte resposta,
Collecting numpy
Downloading
https://files.pythonhosted.org/packages/cf/a4/d5387a74204542a60ad1baa84cd2d3353c330e59be8cf2d47c0b11d3cde8/
numpy-3.1.1-cp36-cp36m-macosx_10_6_intel.
macosx_10_9_intel.macosx_10_9_x86_64.
macosx_10_10_intel.macosx_10_10_x86_64.whl (14.4MB)
|████████████████████████████████| 14.4MB 2.8MB/s
pandas
pip install pandas
Podemos ver a seguinte resposta,
Collecting pandas
Downloading
https://files.pythonhosted.org/packages/cf/a4/d5387a74204542a60ad1baa84cd2d3353c330e59be8cf2d47c0b11d3cde8/
pandas-3.1.1-cp36-cp36m-macosx_10_6_intel.
macosx_10_9_intel.macosx_10_9_x86_64.
macosx_10_10_intel.macosx_10_10_x86_64.whl (14.4MB)
|████████████████████████████████| 14.4MB 2.8MB/s
matplotlib
pip install matplotlib
Podemos ver a seguinte resposta,
Collecting matplotlib
Downloading
https://files.pythonhosted.org/packages/cf/a4/d5387a74204542a60ad1baa84cd2d3353c330e59be8cf2d47c0b11d3cde8/
matplotlib-3.1.1-cp36-cp36m-macosx_10_6_intel.
macosx_10_9_intel.macosx_10_9_x86_64.
macosx_10_10_intel.macosx_10_10_x86_64.whl (14.4MB)
|████████████████████████████████| 14.4MB 2.8MB/s
scipy
pip install scipy
Podemos ver a seguinte resposta,
Collecting scipy
Downloading
https://files.pythonhosted.org/packages/cf/a4/d5387a74204542a60ad1baa84cd2d3353c330e59be8cf2d47c0b11d3cde8
/scipy-3.1.1-cp36-cp36m-macosx_10_6_intel.
macosx_10_9_intel.macosx_10_9_x86_64.
macosx_10_10_intel.macosx_10_10_x86_64.whl (14.4MB)
|████████████████████████████████| 14.4MB 2.8MB/s
scikit-learn
É uma biblioteca de aprendizado de máquina de código aberto. É usado para algoritmos de classificação, regressão e agrupamento. Antes de passar para a instalação, é necessário o seguinte -
- Python versão 3.5 ou superior
- NumPy versão 1.11.0 ou superior
- SciPy versão 0.17.0 ou superior
- joblib 0.11 ou superior.
Agora, instalamos o scikit-learn usando o comando abaixo -
pip install -U scikit-learn
Seaborn
Seaborn é uma biblioteca incrível que permite que você visualize facilmente seus dados. Use o comando abaixo para instalar -
pip pip install seaborninstall -U scikit-learn
Você pode ver uma mensagem semelhante à especificada abaixo -
Collecting seaborn
Downloading
https://files.pythonhosted.org/packages/a8/76/220ba4420459d9c4c9c9587c6ce607bf56c25b3d3d2de62056efe482dadc
/seaborn-0.9.0-py3-none-any.whl (208kB) 100%
|████████████████████████████████| 215kB 4.0MB/s
Requirement already satisfied: numpy> = 1.9.3 in
./lib/python3.7/site-packages (from seaborn) (1.17.0)
Collecting pandas> = 0.15.2 (from seaborn)
Downloading
https://files.pythonhosted.org/packages/39/b7/441375a152f3f9929ff8bc2915218ff1a063a59d7137ae0546db616749f9/
pandas-0.25.0-cp37-cp37m-macosx_10_9_x86_64.
macosx_10_10_x86_64.whl (10.1MB) 100%
|████████████████████████████████| 10.1MB 1.8MB/s
Requirement already satisfied: scipy>=0.14.0 in
./lib/python3.7/site-packages (from seaborn) (1.3.0)
Collecting matplotlib> = 1.4.3 (from seaborn)
Downloading
https://files.pythonhosted.org/packages/c3/8b/af9e0984f
5c0df06d3fab0bf396eb09cbf05f8452de4e9502b182f59c33b/
matplotlib-3.1.1-cp37-cp37m-macosx_10_6_intel.
macosx_10_9_intel.macosx_10_9_x86_64
.macosx_10_10_intel.macosx_10_10_x86_64.whl (14.4MB) 100%
|████████████████████████████████| 14.4MB 1.4MB/s
......................................
......................................
Successfully installed cycler-0.10.0 kiwisolver-1.1.0
matplotlib-3.1.1 pandas-0.25.0 pyparsing-2.4.2
python-dateutil-2.8.0 pytz-2019.2 seaborn-0.9.0
Instalação do Keras usando Python
A partir de agora, concluímos os requisitos básicos para a instalação do Kera. Agora, instale o Keras usando o mesmo procedimento especificado abaixo -
pip install keras
Saia do ambiente virtual
Depois de terminar todas as alterações em seu projeto, basta executar o comando abaixo para sair do ambiente -
deactivate
Nuvem Anaconda
Acreditamos que você tenha instalado a nuvem anaconda em sua máquina. Se o anaconda não estiver instalado, visite o link oficial, www.anaconda.com/distribution e escolha o download com base no seu sistema operacional.
Crie um novo ambiente conda
Inicie o prompt do anaconda, isso abrirá o ambiente base do Anaconda. Vamos criar um novo ambiente de conda. Este processo é semelhante ao virtualenv. Digite o comando abaixo em seu terminal conda -
conda create --name PythonCPU
Se desejar, você também pode criar e instalar módulos usando GPU. Neste tutorial, seguimos as instruções da CPU.
Ativar ambiente conda
Para ativar o ambiente, use o comando abaixo -
activate PythonCPU
Instalar spyder
Spyder é um IDE para executar aplicativos python. Vamos instalar este IDE em nosso ambiente conda usando o comando abaixo -
conda install spyder
Instalar bibliotecas python
Já conhecemos as bibliotecas python numpy, pandas, etc., necessárias para keras. Você pode instalar todos os módulos usando a sintaxe abaixo -
Syntax
conda install -c anaconda <module-name>
Por exemplo, você deseja instalar o pandas -
conda install -c anaconda pandas
Como o mesmo método, tente você mesmo instalar os módulos restantes.
Instale Keras
Agora, tudo parece bem, então você pode iniciar a instalação do keras usando o comando abaixo -
conda install -c anaconda keras
Lançar spyder
Finalmente, inicie o spyder em seu terminal conda usando o comando abaixo -
spyder
Para garantir que tudo foi instalado corretamente, importe todos os módulos, ele irá adicionar tudo e se algo der errado, você receberá module not found mensagem de erro.
Keras - configuração de back-end
Este capítulo explica as implementações de back-end do Keras, TensorFlow e Theano, em detalhes. Vamos examinar cada implementação, uma por uma.
TensorFlow
TensorFlow é uma biblioteca de aprendizado de máquina de código aberto usada para tarefas computacionais numéricas desenvolvidas pelo Google. Keras é uma API de alto nível desenvolvida com base no TensorFlow ou Theano. Já sabemos como instalar o TensorFlow usando pip.
Se não estiver instalado, você pode instalar usando o comando abaixo -
pip install TensorFlow
Depois de executar o keras, podemos ver que o arquivo de configuração está localizado em seu diretório inicial e ir para .keras / keras.json.
keras.json
{
"image_data_format": "channels_last",
"epsilon": 1e-07, "floatx": "float32", "backend": "tensorflow"
}
Aqui,
image_data_format representam o formato dos dados.
epsilonrepresenta a constante numérica. É usado para evitarDivideByZero erro.
floatx representa o tipo de dados padrão float32. Você também pode alterá-lo parafloat16 ou float64 usando set_floatx() método.
image_data_format representam o formato dos dados.
Suponha que, se o arquivo não for criado, mova para o local e crie usando as etapas abaixo -
> cd home
> mkdir .keras
> vi keras.json
Lembre-se, você deve especificar .keras como seu nome de pasta e adicionar a configuração acima dentro do arquivo keras.json. Podemos realizar algumas operações pré-definidas para conhecer as funções de backend.
Theano
Theano é uma biblioteca de aprendizado profundo de código aberto que permite avaliar matrizes multidimensionais de forma eficaz. Podemos instalar facilmente usando o comando abaixo -
pip install theano
Por padrão, o keras usa o back-end do TensorFlow. Se você quiser alterar a configuração do back-end de TensorFlow para Theano, basta alterar backend = theano no arquivo keras.json. É descrito abaixo -
keras.json
{
"image_data_format": "channels_last",
"epsilon": 1e-07,
"floatx": "float32",
"backend": "theano"
}
Agora salve seu arquivo, reinicie seu terminal e inicie o keras, seu backend será alterado.
>>> import keras as k
using theano backend.
Keras - Visão geral do aprendizado profundo
O aprendizado profundo é um subcampo em evolução do aprendizado de máquina. O aprendizado profundo envolve a análise da entrada camada por camada, em que cada camada extrai progressivamente informações de nível superior sobre a entrada.
Tomemos um cenário simples de análise de uma imagem. Vamos supor que sua imagem de entrada seja dividida em uma grade retangular de pixels. Agora, a primeira camada abstrai os pixels. A segunda camada entende as bordas da imagem. A próxima camada constrói nós a partir das bordas. Então, o próximo encontraria ramificações dos nós. Finalmente, a camada de saída detectará o objeto completo. Aqui, o processo de extração de recursos vai da saída de uma camada para a entrada da próxima camada subsequente.
Usando essa abordagem, podemos processar uma grande quantidade de recursos, o que torna o aprendizado profundo uma ferramenta muito poderosa. Algoritmos de aprendizado profundo também são úteis para a análise de dados não estruturados. Vamos examinar os fundamentos do aprendizado profundo neste capítulo.
Redes neurais artificiais
A abordagem mais popular e primária de aprendizado profundo é o uso de “Rede neural artificial” (RNA). Eles são inspirados no modelo do cérebro humano, que é o órgão mais complexo do nosso corpo. O cérebro humano é composto por mais de 90 bilhões de células minúsculas chamadas “neurônios”. Os neurônios estão interconectados por meio de fibras nervosas chamadas “axônios” e “Dendritos”. O principal papel do axônio é transmitir informações de um neurônio para outro ao qual está conectado.
Da mesma forma, o principal papel dos dendritos é receber a informação que está sendo transmitida pelos axônios de outro neurônio ao qual está conectado. Cada neurônio processa uma pequena informação e então passa o resultado para outro neurônio e este processo continua. Este é o método básico usado pelo nosso cérebro humano para processar muitas informações como fala, visual, etc., e extrair informações úteis delas.
Com base neste modelo, a primeira Rede Neural Artificial (RNA) foi inventada por psicólogo Frank Rosenblatt, no ano de 1958. As RNAs são constituídas por múltiplos nós, semelhantes aos neurônios. Os nós são fortemente interconectados e organizados em diferentes camadas ocultas. A camada de entrada recebe os dados de entrada e os dados passam por uma ou mais camadas ocultas sequencialmente e, por fim, a camada de saída prevê algo útil sobre os dados de entrada. Por exemplo, a entrada pode ser uma imagem e a saída pode ser a coisa identificada na imagem, digamos um “Gato”.
Um único neurônio (chamado de perceptron na RNA) pode ser representado como abaixo -
Aqui,
A entrada múltipla junto com o peso representa dendritos.
A soma da entrada junto com a função de ativação representa os neurônios. Sum na verdade, significa o valor calculado de todas as entradas e a função de ativação representa uma função, que modifica o Sum valor em 0, 1 ou 0 a 1.
A saída real representa o axônio e a saída será recebida pelo neurônio na próxima camada.
Vamos entender os diferentes tipos de redes neurais artificiais nesta seção.
Perceptron Multi-Camada
Perceptron multicamadas é a forma mais simples de RNA. Consiste em uma única camada de entrada, uma ou mais camadas ocultas e, finalmente, uma camada de saída. Uma camada consiste em uma coleção de perceptron. A camada de entrada é basicamente um ou mais recursos dos dados de entrada. Cada camada oculta consiste em um ou mais neurônios e processa certos aspectos do recurso e envia as informações processadas para a próxima camada oculta. O processo da camada de saída recebe os dados da última camada oculta e finalmente produz o resultado.
Rede Neural Convolucional (CNN)
A rede neural convolucional é uma das RNA mais populares. É amplamente utilizado nas áreas de reconhecimento de imagem e vídeo. É baseado no conceito de convolução, um conceito matemático. É quase semelhante ao perceptron multicamadas, exceto que contém uma série de camada de convolução e camada de pooling antes da camada de neurônio oculta totalmente conectada. Tem três camadas importantes -
Convolution layer - É o bloco de construção primário e executa tarefas computacionais com base na função de convolução.
Pooling layer - É organizado próximo à camada de convolução e é usado para reduzir o tamanho das entradas, removendo informações desnecessárias para que a computação possa ser executada mais rapidamente.
Fully connected layer - É organizado ao lado de uma série de convolução e camada de agrupamento e classifica a entrada em várias categorias.
Uma simples CNN pode ser representada como abaixo -
Aqui,
2 séries de camada de convolução e pooling são usadas e recebem e processam a entrada (por exemplo, imagem).
Uma única camada totalmente conectada é usada e é usada para produzir os dados (por exemplo, classificação de imagem)
Rede Neural Recorrente (RNN)
Redes Neurais Recorrentes (RNN) são úteis para resolver a falha em outros modelos de RNA. Bem, a maior parte da RNA não se lembra das etapas de situações anteriores e aprendeu a tomar decisões com base no contexto do treinamento. Enquanto isso, a RNN armazena as informações anteriores e todas as suas decisões são tomadas com base no que aprendeu no passado.
Essa abordagem é útil principalmente na classificação de imagens. Às vezes, podemos precisar olhar para o futuro para consertar o passado. Nesse caso, o RNN bidirecional é útil para aprender com o passado e prever o futuro. Por exemplo, temos amostras manuscritas em várias entradas. Suponha que haja confusão em uma entrada, então precisamos verificar novamente outras entradas para reconhecer o contexto correto que toma a decisão do passado.
Fluxo de trabalho da RNA
Vamos primeiro entender as diferentes fases do aprendizado profundo e, em seguida, aprender como Keras ajuda no processo de aprendizado profundo.
Colete os dados necessários
O aprendizado profundo requer muitos dados de entrada para aprender e prever o resultado com sucesso. Portanto, primeiro colete o máximo de dados possível.
Analisar dados
Analise os dados e adquira uma boa compreensão dos dados. O melhor entendimento dos dados é necessário para selecionar o algoritmo ANN correto.
Escolha um algoritmo (modelo)
Escolha um algoritmo que se adapte melhor ao tipo de processo de aprendizagem (por exemplo, classificação de imagem, processamento de texto, etc.) e aos dados de entrada disponíveis. Algoritmo é representado porModelem Keras. O algoritmo inclui uma ou mais camadas. Cada camada em ANN pode ser representada porKeras Layer em Keras.
Prepare data - Processe, filtre e selecione apenas as informações necessárias dos dados.
Split data- Divida os dados em conjunto de dados de treinamento e teste. Os dados de teste serão usados para avaliar a previsão do algoritmo / Modelo (uma vez que a máquina aprenda) e para cruzar a verificação da eficiência do processo de aprendizagem.
Compile the model- Compilar o algoritmo / modelo, de forma que possa ser usado posteriormente para aprender por treinamento e finalmente fazer predição. Esta etapa exige que escolhamos a função de perda e o Otimizador. A função de perda e o Otimizador são usados na fase de aprendizagem para encontrar o erro (desvio da saída real) e fazer a otimização de forma que o erro seja minimizado.
Fit the model - O processo de aprendizagem real será feito nesta fase usando o conjunto de dados de treinamento.
Predict result for unknown value - Prever a saída para os dados de entrada desconhecidos (além dos dados de treinamento e teste existentes)
Evaluate model - Avalie o modelo prevendo a saída dos dados de teste e comparando a previsão com o resultado real dos dados de teste.
Freeze, Modify or choose new algorithm- Verifique se a avaliação do modelo foi bem-sucedida. Se sim, salve o algoritmo para fins de previsão futura. Caso contrário, modifique ou escolha um novo algoritmo / modelo e, finalmente, treine, preveja e avalie o modelo novamente. Repita o processo até que o melhor algoritmo (modelo) seja encontrado.
As etapas acima podem ser representadas usando o fluxograma abaixo -
Keras - Aprendizagem profunda
Keras fornece uma estrutura completa para criar qualquer tipo de rede neural. Keras é inovador e muito fácil de aprender. Ele suporta rede neural simples para modelo de rede neural muito grande e complexo. Vamos entender a arquitetura da estrutura Keras e como Keras ajuda no aprendizado profundo neste capítulo.
Arquitetura de Keras
Keras API pode ser dividida em três categorias principais -
- Model
- Layer
- Módulos principais
Em Keras, cada RNA é representado por Keras Models. Por sua vez, cada modelo Keras é uma composição deKeras Layers e representa camadas ANN como entrada, camada oculta, camadas de saída, camada de convolução, camada de pooling, etc., modelo Keras e acesso à camada Keras modules para função de ativação, função de perda, função de regularização, etc., Usando o modelo Keras, camada Keras e módulos Keras, qualquer algoritmo ANN (CNN, RNN, etc.) pode ser representado de maneira simples e eficiente.
O diagrama a seguir descreve a relação entre o modelo, a camada e os módulos principais -
Vamos ver a visão geral dos modelos Keras, camadas Keras e módulos Keras.
Modelo
Os modelos Keras são de dois tipos, conforme mencionado abaixo -
Sequential Model- O modelo sequencial é basicamente uma composição linear de camadas Keras. O modelo sequencial é fácil, mínimo e tem a capacidade de representar quase todas as redes neurais disponíveis.
Um modelo sequencial simples é o seguinte -
from keras.models import Sequential
from keras.layers import Dense, Activation
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,)))
Onde,
Line 1 importações Sequential modelo dos modelos Keras
Line 2 importações Dense camada e Activation módulo
Line 4 criar um novo modelo sequencial usando Sequential API
Line 5 adiciona uma camada densa (Dense API) com relu função de ativação (usando o módulo de ativação).
Sequential modelo expõe Modelclasse para criar modelos personalizados também. Podemos usar o conceito de subclasse para criar nosso próprio modelo complexo.
Functional API - A API funcional é basicamente usada para criar modelos complexos.
Camada
Cada camada Keras no modelo Keras representa a camada correspondente (camada de entrada, camada oculta e camada de saída) no modelo de rede neural proposto. Keras fornece muitas camadas pré-construídas para que qualquer rede neural complexa possa ser criada facilmente. Algumas das camadas Keras importantes são especificadas abaixo,
- Camadas principais
- Camadas de Convolução
- Camadas de pooling
- Camadas Recorrentes
Um código python simples para representar um modelo de rede neural usando sequential modelo é o seguinte -
from keras.models import Sequential
from keras.layers import Dense, Activation, Dropout model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,)))
model.add(Dropout(0.2))
model.add(Dense(512, activation = 'relu')) model.add(Dropout(0.2))
model.add(Dense(num_classes, activation = 'softmax'))
Onde,
Line 1 importações Sequential modelo dos modelos Keras
Line 2 importações Dense camada e Activation módulo
Line 4 criar um novo modelo sequencial usando Sequential API
Line 5 adiciona uma camada densa (Dense API) com relu função de ativação (usando o módulo de ativação).
Line 6 adiciona uma camada dropout (API Dropout) para lidar com o sobreajuste.
Line 7 adiciona outra camada densa (Dense API) com relu função de ativação (usando o módulo de ativação).
Line 8 adiciona outra camada de eliminação (API Dropout) para lidar com o sobreajuste.
Line 9 adiciona camada densa final (Dense API) com softmax função de ativação (usando o módulo de ativação).
Keras também oferece opções para criar nossas próprias camadas personalizadas. Camada personalizada pode ser criada subclassificando oKeras.Layer classe e é semelhante à subclassificação dos modelos Keras.
Módulos principais
Keras também fornece várias funções integradas relacionadas à rede neural para criar adequadamente o modelo Keras e as camadas Keras. Algumas das funções são as seguintes -
Activations module - A função de ativação é um conceito importante em RNA e os módulos de ativação fornecem muitas funções de ativação, como softmax, relu, etc.,
Loss module - O módulo de perda fornece funções de perda como mean_squared_error, mean_absolute_error, poisson, etc.,
Optimizer module - O módulo Otimizador fornece funções de otimizador como adam, sgd, etc.,
Regularizers - O módulo Regularizer fornece funções como regularizador L1, regularizador L2, etc.,
Vamos aprender os módulos Keras em detalhes no próximo capítulo.
Keras - Módulos
Como aprendemos anteriormente, os módulos Keras contêm classes, funções e variáveis predefinidas que são úteis para algoritmos de aprendizado profundo. Vamos aprender os módulos fornecidos por Keras neste capítulo.
Módulos Disponíveis
Vamos primeiro ver a lista de módulos disponíveis no Keras.
Initializers- Fornece uma lista de função de inicializadores. Podemos aprender em detalhes no capítulo da camada Keras . durante a fase de criação do modelo de aprendizado de máquina.
Regularizers- Fornece uma lista de funções de regularizadores. Podemos aprender em detalhes no capítulo Camadas Keras .
Constraints- Fornece uma lista de funções de restrições. Podemos aprender em detalhes no capítulo Camadas Keras .
Activations- Fornece uma lista de funções ativadoras. Podemos aprender em detalhes no capítulo Camadas Keras .
Losses- Fornece uma lista de função de perda. Podemos aprender em detalhes no capítulo Treinamento do modelo .
Metrics- Fornece uma lista de funções de métricas. Podemos aprender em detalhes no capítulo Treinamento do modelo .
Optimizers- Fornece uma lista de funções do otimizador. Podemos aprender em detalhes no capítulo Treinamento do modelo .
Callback- Fornece uma lista de função de retorno de chamada. Podemos usá-lo durante o processo de treinamento para imprimir os dados intermediários, bem como para interromper o próprio treinamento (EarlyStopping método) com base em alguma condição.
Text processing- Fornece funções para converter texto em array NumPy adequado para aprendizado de máquina. Podemos usá-lo na fase de preparação de dados do aprendizado de máquina.
Image processing- Fornece funções para converter imagens em array NumPy adequado para aprendizado de máquina. Podemos usá-lo na fase de preparação de dados do aprendizado de máquina.
Sequence processing- Fornece funções para gerar dados baseados no tempo a partir dos dados de entrada fornecidos. Podemos usá-lo na fase de preparação de dados do aprendizado de máquina.
Backend- Fornece a função da biblioteca backend como TensorFlow e Theano .
Utilities - Fornece muitas funções utilitárias úteis no aprendizado profundo.
Deixe-nos ver backend módulo e utils modelo neste capítulo.
módulo de backend
backend moduleé usado para operações de back-end do keras. Por padrão, o keras é executado no back-end do TensorFlow. Se desejar, você pode alternar para outros back-ends, como Theano ou CNTK. A configuração do back-end Defualt é definida dentro de seu diretório raiz no arquivo .keras / keras.json.
O módulo de backend Keras pode ser importado usando o código abaixo
>>> from keras import backend as k
Se estivermos usando o TensorFlow de back-end padrão , a função abaixo retornará informações baseadas no TensorFlow conforme especificado abaixo -
>>> k.backend()
'tensorflow'
>>> k.epsilon()
1e-07
>>> k.image_data_format()
'channels_last'
>>> k.floatx()
'float32'
Vamos entender algumas das funções de back-end significativas usadas para análise de dados em breve -
get_uid ()
É o identificador do gráfico padrão. É definido abaixo -
>>> k.get_uid(prefix='')
1
>>> k.get_uid(prefix='') 2
reset_uids
Ele é usado para redefinir o valor uid.
>>> k.reset_uids()
Agora, execute novamente o get_uid () . Isso será redefinido e alterado novamente para 1.
>>> k.get_uid(prefix='')
1
placeholder
É usado para instanciar um tensor de espaço reservado. Um espaço reservado simples para manter a forma 3-D é mostrado abaixo -
>>> data = k.placeholder(shape = (1,3,3))
>>> data
<tf.Tensor 'Placeholder_9:0' shape = (1, 3, 3) dtype = float32>
If you use int_shape(), it will show the shape.
>>> k.int_shape(data) (1, 3, 3)
ponto
É usado para multiplicar dois tensores. Considere que aeb são dois tensores e c será o resultado da multiplicação de ab. Suponha que a forma seja (4,2) e a forma b seja (2,3). É definido abaixo,
>>> a = k.placeholder(shape = (4,2))
>>> b = k.placeholder(shape = (2,3))
>>> c = k.dot(a,b)
>>> c
<tf.Tensor 'MatMul_3:0' shape = (4, 3) dtype = float32>
>>>
uns
É usado para inicializar tudo como one valor.
>>> res = k.ones(shape = (2,2))
#print the value
>>> k.eval(res)
array([[1., 1.], [1., 1.]], dtype = float32)
batch_dot
É utilizado para realizar o produto de dois dados em lotes. A dimensão de entrada deve ser 2 ou superior. É mostrado abaixo -
>>> a_batch = k.ones(shape = (2,3))
>>> b_batch = k.ones(shape = (3,2))
>>> c_batch = k.batch_dot(a_batch,b_batch)
>>> c_batch
<tf.Tensor 'ExpandDims:0' shape = (2, 1) dtype = float32>
variável
É usado para inicializar uma variável. Vamos realizar uma operação simples de transposição nesta variável.
>>> data = k.variable([[10,20,30,40],[50,60,70,80]])
#variable initialized here
>>> result = k.transpose(data)
>>> print(result)
Tensor("transpose_6:0", shape = (4, 2), dtype = float32)
>>> print(k.eval(result))
[[10. 50.]
[20. 60.]
[30. 70.]
[40. 80.]]
Se você deseja acessar de numpy -
>>> data = np.array([[10,20,30,40],[50,60,70,80]])
>>> print(np.transpose(data))
[[10 50]
[20 60]
[30 70]
[40 80]]
>>> res = k.variable(value = data)
>>> print(res)
<tf.Variable 'Variable_7:0' shape = (2, 4) dtype = float32_ref>
is_sparse (tensor)
É usado para verificar se o tensor é esparso ou não.
>>> a = k.placeholder((2, 2), sparse=True)
>>> print(a) SparseTensor(indices =
Tensor("Placeholder_8:0",
shape = (?, 2), dtype = int64),
values = Tensor("Placeholder_7:0", shape = (?,),
dtype = float32), dense_shape = Tensor("Const:0", shape = (2,), dtype = int64))
>>> print(k.is_sparse(a)) True
to_dense ()
É usado para converter esparso em denso.
>>> b = k.to_dense(a)
>>> print(b) Tensor("SparseToDense:0", shape = (2, 2), dtype = float32)
>>> print(k.is_sparse(b)) False
random_uniform_variable
É usado para inicializar usando uniform distribution conceito.
k.random_uniform_variable(shape, mean, scale)
Aqui,
shape - denota as linhas e colunas no formato de tuplas.
mean - média de distribuição uniforme.
scale - desvio padrão da distribuição uniforme.
Vamos dar uma olhada no exemplo de uso abaixo -
>>> a = k.random_uniform_variable(shape = (2, 3), low=0, high = 1)
>>> b = k. random_uniform_variable(shape = (3,2), low = 0, high = 1)
>>> c = k.dot(a, b)
>>> k.int_shape(c)
(2, 2)
módulo utils
utilsfornece funções de utilitários úteis para aprendizado profundo. Alguns dos métodos fornecidos peloutils módulo é o seguinte -
HDF5Matrix
É usado para representar os dados de entrada no formato HDF5.
from keras.utils import HDF5Matrix data = HDF5Matrix('data.hdf5', 'data')
to_categorical
É usado para converter o vetor de classe em matriz de classe binária.
>>> from keras.utils import to_categorical
>>> labels = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> to_categorical(labels)
array([[1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 1.]], dtype = float32)
>>> from keras.utils import normalize
>>> normalize([1, 2, 3, 4, 5])
array([[0.13483997, 0.26967994, 0.40451992, 0.53935989, 0.67419986]])
print_summary
É usado para imprimir o resumo do modelo.
from keras.utils import print_summary print_summary(model)
plot_model
É usado para criar a representação do modelo em formato de ponto e salvá-la em um arquivo.
from keras.utils import plot_model
plot_model(model,to_file = 'image.png')
este plot_model irá gerar uma imagem para entender o desempenho do modelo.
Keras - camadas
Conforme aprendido anteriormente, as camadas Keras são o bloco de construção principal dos modelos Keras. Cada camada recebe informações de entrada, faz alguns cálculos e, por fim, produz as informações transformadas. A saída de uma camada fluirá para a próxima camada como sua entrada. Vamos aprender detalhes completos sobre as camadas neste capítulo.
Introdução
Uma camada Keras requer shape of the input (input_shape) para entender a estrutura dos dados de entrada, initializerpara definir o peso de cada entrada e, finalmente, ativadores para transformar a saída para torná-la não linear. No meio, as restrições restringem e especificam o intervalo no qual o peso dos dados de entrada a serem gerados e o regularizador tentará otimizar a camada (e o modelo) aplicando dinamicamente as penalidades nos pesos durante o processo de otimização.
Para resumir, a camada Keras requer os detalhes mínimos abaixo para criar uma camada completa.
- Forma dos dados de entrada
- Número de neurônios / unidades na camada
- Initializers
- Regularizers
- Constraints
- Activations
Vamos entender o conceito básico no próximo capítulo. Antes de entender o conceito básico, vamos criar uma camada Keras simples usando a API do modelo sequencial para ter uma ideia de como o modelo e a camada Keras funcionam.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
from keras import regularizers
from keras import constraints
model = Sequential()
model.add(Dense(32, input_shape=(16,), kernel_initializer = 'he_uniform',
kernel_regularizer = None, kernel_constraint = 'MaxNorm', activation = 'relu'))
model.add(Dense(16, activation = 'relu'))
model.add(Dense(8))
Onde,
Line 1-5 importa os módulos necessários.
Line 7 cria um novo modelo usando API sequencial.
Line 9 cria um novo Dense camada e adicione-o ao modelo. Denseé uma camada de nível de entrada fornecida por Keras, que aceita o número de neurônios ou unidades (32) como seu parâmetro obrigatório. Se a camada for a primeira camada, precisamos fornecerInput Shape, (16,)também. Caso contrário, a saída da camada anterior será usada como entrada da próxima camada. Todos os outros parâmetros são opcionais.
O primeiro parâmetro representa o número de unidades (neurônios).
input_shape representam a forma dos dados de entrada.
kernel_initializer representa o inicializador a ser usado. he_uniform função é definida como valor.
kernel_regularizer representar regularizerser usado. Nenhum é definido como valor.
kernel_constraint representam a restrição a ser usada. MaxNorm função é definida como valor.
activationrepresentam a ativação a ser usada. a função relu é definida como valor.
Line 10 cria segundo Dense camada com 16 unidades e conjunto relu como a função de ativação.
Line 11 cria a camada Densa final com 8 unidades.
Conceito Básico de Camadas
Vamos entender o conceito básico de camada e também como Keras apóia cada conceito.
Forma de entrada
No aprendizado de máquina, todos os tipos de dados de entrada como texto, imagens ou vídeos serão primeiro convertidos em uma matriz de números e, em seguida, alimentados no algoritmo. Os números de entrada podem ser matriz unidimensional, matriz bidimensional (matriz) ou matriz multidimensional. Podemos especificar as informações dimensionais usandoshape, uma tupla de inteiros. Por exemplo,(4,2) representam a matriz com quatro linhas e duas colunas.
>>> import numpy as np
>>> shape = (4, 2)
>>> input = np.zeros(shape)
>>> print(input)
[
[0. 0.]
[0. 0.]
[0. 0.]
[0. 0.]
]
>>>
Similarmente, (3,4,2) matriz tridimensional com três coleções de matriz 4x2 (duas linhas e quatro colunas).
>>> import numpy as np
>>> shape = (3, 4, 2)
>>> input = np.zeros(shape)
>>> print(input)
[
[[0. 0.] [0. 0.] [0. 0.] [0. 0.]]
[[0. 0.] [0. 0.] [0. 0.] [0. 0.]]
[[0. 0.] [0. 0.] [0. 0.] [0. 0.]]
]
>>>
Para criar a primeira camada do modelo (ou camada de entrada do modelo), a forma dos dados de entrada deve ser especificada.
Inicializadores
No aprendizado de máquina, o peso será atribuído a todos os dados de entrada. InitializersO módulo fornece diferentes funções para definir esses pesos iniciais. Alguns dosKeras Initializer função são as seguintes -
Zeros
Gera 0 para todos os dados de entrada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.Zeros()
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))
Onde, kernel_initializer representam o inicializador para o kernel do modelo.
uns
Gera 1 para todos os dados de entrada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.Ones()
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))
Constante
Gera um valor constante (digamos, 5) especificado pelo usuário para todos os dados de entrada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.Constant(value = 0) model.add(
Dense(512, activation = 'relu', input_shape = (784,), kernel_initializer = my_init)
)
Onde, value representam o valor constante
RandomNormal
Gera valor usando distribuição normal de dados de entrada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.RandomNormal(mean=0.0,
stddev = 0.05, seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))
Onde,
mean representam a média dos valores aleatórios para gerar
stddev representam o desvio padrão dos valores aleatórios para gerar
seed representam os valores para gerar um número aleatório
RandomUniform
Gera valor usando distribuição uniforme de dados de entrada.
from keras import initializers
my_init = initializers.RandomUniform(minval = -0.05, maxval = 0.05, seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))
Onde,
minval representam o limite inferior dos valores aleatórios para gerar
maxval representam o limite superior dos valores aleatórios para gerar
TruncatedNormal
Gera valor usando distribuição normal truncada de dados de entrada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.TruncatedNormal(mean = 0.0, stddev = 0.05, seed = None
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))
VarianceScaling
Gera valor com base na forma de entrada e forma de saída da camada junto com a escala especificada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.VarianceScaling(
scale = 1.0, mode = 'fan_in', distribution = 'normal', seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
skernel_initializer = my_init))
Onde,
scale representam o fator de escala
mode representar qualquer um de fan_in, fan_out e fan_avg valores
distribution representar qualquer um dos normal ou uniform
VarianceScaling
Encontra o stddev valor para a distribuição normal usando a fórmula abaixo e, em seguida, encontre os pesos usando a distribuição normal,
stddev = sqrt(scale / n)
Onde n representar,
número de unidades de entrada para modo = fan_in
número de unidades externas para modo = fan_out
número médio de unidades de entrada e saída para modo = fan_avg
Da mesma forma, ele encontra o limite para distribuição uniforme usando a fórmula abaixo e, em seguida, encontra os pesos usando distribuição uniforme,
limit = sqrt(3 * scale / n)
lecun_normal
Gera valor usando a distribuição normal lecun de dados de entrada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.RandomUniform(minval = -0.05, maxval = 0.05, seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))
Encontra o stddev usando a fórmula abaixo e, em seguida, aplique a distribuição normal
stddev = sqrt(1 / fan_in)
Onde, fan_in representam o número de unidades de entrada.
lecun_uniform
Gera valor usando a distribuição uniforme lecun de dados de entrada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.lecun_uniform(seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))
Encontra o limit usando a fórmula abaixo e, em seguida, aplique a distribuição uniforme
limit = sqrt(3 / fan_in)
Onde,
fan_in representa o número de unidades de entrada
fan_out representa o número de unidades de produção
glorot_normal
Gera valor usando distribuição normal glorot de dados de entrada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.glorot_normal(seed=None) model.add(
Dense(512, activation = 'relu', input_shape = (784,), kernel_initializer = my_init)
)
Encontra o stddev usando a fórmula abaixo e, em seguida, aplique a distribuição normal
stddev = sqrt(2 / (fan_in + fan_out))
Onde,
fan_in representa o número de unidades de entrada
fan_out representa o número de unidades de produção
glorot_uniform
Gera valor usando a distribuição uniforme glorot de dados de entrada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.glorot_uniform(seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))
Encontra o limit usando a fórmula abaixo e, em seguida, aplique a distribuição uniforme
limit = sqrt(6 / (fan_in + fan_out))
Onde,
fan_in representam o número de unidades de entrada.
fan_out representa o número de unidades de produção
he_normal
Gera valor usando a distribuição normal de dados de entrada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.RandomUniform(minval = -0.05, maxval = 0.05, seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))
Ele encontra o stddev usando a fórmula abaixo e, em seguida, aplica a distribuição normal.
stddev = sqrt(2 / fan_in)
Onde, fan_in representam o número de unidades de entrada.
he_uniforme
Gera valor usando a distribuição uniforme de dados de entrada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.he_normal(seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))
Encontra o limit usando a fórmula abaixo e, em seguida, aplique uma distribuição uniforme.
limit = sqrt(6 / fan_in)
Onde, fan_in representam o número de unidades de entrada.
Ortogonal
Gera uma matriz ortogonal aleatória.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.Orthogonal(gain = 1.0, seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))
Onde, gain representam o fator de multiplicação da matriz.
Identidade
Gera matriz de identidade.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.Identity(gain = 1.0) model.add(
Dense(512, activation = 'relu', input_shape = (784,), kernel_initializer = my_init)
)
Restrições
No aprendizado de máquina, uma restrição será definida no parâmetro (peso) durante a fase de otimização. <> O módulo de restrições fornece diferentes funções para definir a restrição na camada. Algumas das funções de restrição são as seguintes.
NonNeg
Limita os pesos a não negativos.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.Identity(gain = 1.0) model.add(
Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init)
)
Onde, kernel_constraint representam a restrição a ser usada na camada.
UnitNorm
Limita os pesos para serem norma unitária.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import constraints
my_constrain = constraints.UnitNorm(axis = 0)
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_constraint = my_constrain))
MaxNorm
Limita o peso à norma menor ou igual ao valor fornecido.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import constraints
my_constrain = constraints.MaxNorm(max_value = 2, axis = 0)
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_constraint = my_constrain))
Onde,
max_value representam o limite superior
eixo representa a dimensão na qual a restrição a ser aplicada. por exemplo, em Forma (2,3,4) o eixo 0 denota a primeira dimensão, 1 denota a segunda dimensão e 2 denota a terceira dimensão
MinMaxNorm
Restringe os pesos para serem normais entre os valores mínimo e máximo especificados.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import constraints
my_constrain = constraints.MinMaxNorm(min_value = 0.0, max_value = 1.0, rate = 1.0, axis = 0)
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_constraint = my_constrain))
Onde, rate representam a taxa na qual a restrição de peso é aplicada.
Regularizadores
No aprendizado de máquina, os regularizadores são usados na fase de otimização. Ele aplica algumas penalidades no parâmetro da camada durante a otimização. O módulo de regularização Keras fornece as funções abaixo para definir penalidades na camada. A regularização aplica-se apenas por camada.
Regularizador L1
Ele fornece regularização baseada em L1.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import regularizers
my_regularizer = regularizers.l1(0.)
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_regularizer = my_regularizer))
Onde, kernel_regularizer representam a taxa na qual a restrição de peso é aplicada.
Regularizador L2
Ele fornece regularização baseada em L2.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import regularizers
my_regularizer = regularizers.l2(0.)
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_regularizer = my_regularizer))
Regularizador L1 e L2
Ele fornece regularização baseada em L1 e L2.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import regularizers
my_regularizer = regularizers.l2(0.)
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_regularizer = my_regularizer))
Ativações
No aprendizado de máquina, a função de ativação é uma função especial usada para descobrir se um neurônio específico está ativado ou não. Basicamente, a função de ativação faz uma transformação não linear dos dados de entrada e, assim, permite que os neurônios aprendam melhor. A saída de um neurônio depende da função de ativação.
Como você lembra do conceito de percepção única, a saída de um perceptron (neurônio) é simplesmente o resultado da função de ativação, que aceita a soma de todas as entradas multiplicadas com seu peso correspondente mais o viés geral, se houver.
result = Activation(SUMOF(input * weight) + bias)
Portanto, a função de ativação desempenha um papel importante no aprendizado bem-sucedido do modelo. Keras fornece várias funções de ativação no módulo de ativação. Vamos conhecer todas as ativações disponíveis no módulo.
linear
Aplica a função Linear. Faz nada.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'linear', input_shape = (784,)))
Onde, activationrefere-se à função de ativação da camada. Ele pode ser especificado simplesmente pelo nome da função e a camada usará os ativadores correspondentes.
elu
Aplica unidade linear exponencial.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'elu', input_shape = (784,)))
selu
Aplica a unidade linear exponencial com escala.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'selu', input_shape = (784,)))
relu
Aplica unidade linear retificada.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,)))
softmax
Aplica a função Softmax.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'softmax', input_shape = (784,)))
softplus
Aplica a função Softplus.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'softplus', input_shape = (784,)))
softsign
Aplica a função Softsign.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'softsign', input_shape = (784,)))
tanh
Aplica a função tangente hiperbólica.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'tanh', input_shape = (784,)))
sigmóide
Aplica a função Sigmoid.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'sigmoid', input_shape = (784,)))
hard_sigmoid
Aplica a função Sigmoid Hard.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'hard_sigmoid', input_shape = (784,)))
exponencial
Aplica função exponencial.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'exponential', input_shape = (784,)))
Sr. Não | Camadas e descrição |
---|---|
1 | Camada Densa Dense layer é a camada de rede neural profundamente conectada regular. |
2 | Camadas de exclusão Dropout é um dos conceitos importantes no aprendizado de máquina. |
3 | Camadas planas Flatten é usado para nivelar a entrada. |
4 | Remodelar camadas Reshape é usado para alterar a forma da entrada. |
5 | Camadas permutadas Permute também é usado para alterar a forma da entrada usando o padrão. |
6 | Camadas de vetor repetido RepeatVector é usado para repetir a entrada para o número definido, n de vezes. |
7 | Camadas Lambda Lambda é usado para transformar os dados de entrada usando uma expressão ou função. |
8 | Camadas de Convolução Keras contém muitas camadas para a criação de RNA baseada em convolução, popularmente chamada de Rede Neural de Convolução (CNN) . |
9 | Camada de pooling É usado para executar operações de pooling máximas em dados temporais. |
10 | Camada conectada localmente Camadas conectadas localmente são semelhantes à camada Conv1D, mas a diferença é que os pesos das camadas Conv1D são compartilhados, mas aqui os pesos não são compartilhados. |
11 | Mesclar Camada É usado para mesclar uma lista de entradas. |
12 | Camada de incorporação Ele executa operações de incorporação na camada de entrada. |
Keras - Camada Personalizada
Keras permite criar nossa própria camada personalizada. Depois que uma nova camada é criada, ela pode ser usada em qualquer modelo sem nenhuma restrição. Vamos aprender como criar uma nova camada neste capítulo.
Keras fornece uma base layerclasse, camada que pode ser subclassificada para criar nossa própria camada personalizada. Vamos criar uma camada simples que encontrará o peso com base na distribuição normal e, em seguida, fazer o cálculo básico para encontrar a soma do produto da entrada e seu peso durante o treinamento.
Etapa 1: importe o módulo necessário
Primeiro, vamos importar os módulos necessários -
from keras import backend as K
from keras.layers import Layer
Aqui,
backend é usado para acessar o dot função.
Layer é a classe base e iremos subclassificá-la para criar nossa camada
Etapa 2: definir uma classe de camada
Vamos criar uma nova classe, MyCustomLayer por subclassificação Layer class -
class MyCustomLayer(Layer):
...
Etapa 3: inicializar a classe de camada
Vamos inicializar nossa nova classe conforme especificado abaixo -
def __init__(self, output_dim, **kwargs):
self.output_dim = output_dim
super(MyCustomLayer, self).__init__(**kwargs)
Aqui,
Line 2 define a dimensão de saída.
Line 3 chama a base ou super camada init função.
Etapa 4: implemente o método de construção
buildé o método principal e seu único propósito é construir a camada corretamente. Ele pode fazer qualquer coisa relacionada ao funcionamento interno da camada. Assim que a funcionalidade personalizada estiver concluída, podemos chamar a classe basebuildfunção. Nosso costumebuild função é a seguinte -
def build(self, input_shape):
self.kernel = self.add_weight(name = 'kernel',
shape = (input_shape[1], self.output_dim),
initializer = 'normal', trainable = True)
super(MyCustomLayer, self).build(input_shape)
Aqui,
Line 1 define o build método com um argumento, input_shape. O formato dos dados de entrada é referido por input_shape.
Line 2cria o peso correspondente à forma de entrada e o define no kernel. É nossa funcionalidade personalizada da camada. Ele cria o peso usando o inicializador 'normal'.
Line 6 chama a classe base, build método.
Etapa 5: implemente o método de chamada
call método faz o trabalho exato da camada durante o processo de treinamento.
Nosso costume call método é o seguinte
def call(self, input_data):
return K.dot(input_data, self.kernel)
Aqui,
Line 1 define o call método com um argumento, input_data. input_data são os dados de entrada para nossa camada.
Line 2 retornar o produto escalar dos dados de entrada, input_data e o kernel da nossa camada, self.kernel
Etapa 6: Implementar o método compute_output_shape
def compute_output_shape(self, input_shape): return (input_shape[0], self.output_dim)
Aqui,
Line 1 define compute_output_shape método com um argumento input_shape
Line 2 calcula a forma de saída usando a forma dos dados de entrada e as dimensões de saída definidas ao inicializar a camada.
Implementando o build, call e compute_output_shapeconclui a criação de uma camada personalizada. O código final e completo é o seguinte
from keras import backend as K from keras.layers import Layer
class MyCustomLayer(Layer):
def __init__(self, output_dim, **kwargs):
self.output_dim = output_dim
super(MyCustomLayer, self).__init__(**kwargs)
def build(self, input_shape): self.kernel =
self.add_weight(name = 'kernel',
shape = (input_shape[1], self.output_dim),
initializer = 'normal', trainable = True)
super(MyCustomLayer, self).build(input_shape) #
Be sure to call this at the end
def call(self, input_data): return K.dot(input_data, self.kernel)
def compute_output_shape(self, input_shape): return (input_shape[0], self.output_dim)
Usando nossa camada personalizada
Vamos criar um modelo simples usando nossa camada personalizada conforme especificado abaixo -
from keras.models import Sequential
from keras.layers import Dense
model = Sequential()
model.add(MyCustomLayer(32, input_shape = (16,)))
model.add(Dense(8, activation = 'softmax')) model.summary()
Aqui,
Nosso MyCustomLayer é adicionado ao modelo usando 32 unidades e (16,) como forma de entrada
Executar o aplicativo imprimirá o resumo do modelo conforme abaixo -
Model: "sequential_1"
_________________________________________________________________
Layer (type) Output Shape Param
#================================================================
my_custom_layer_1 (MyCustomL (None, 32) 512
_________________________________________________________________
dense_1 (Dense) (None, 8) 264
=================================================================
Total params: 776
Trainable params: 776
Non-trainable params: 0
_________________________________________________________________
Keras - Modelos
Conforme aprendido anteriormente, o modelo Keras representa o modelo real da rede neural. Keras fornece dois modos para criar o modelo, API sequencial simples e fácil de usar , bem como API funcional mais flexível e avançada . Vamos aprender agora a criar um modelo usando API sequencial e funcional neste capítulo.
Sequencial
A ideia central de Sequential APIé simplesmente organizar as camadas Keras em uma ordem sequencial e, portanto, é chamado de API Sequencial . A maioria das RNA também tem camadas em ordem sequencial e os dados fluem de uma camada para outra na ordem dada até que os dados finalmente alcancem a camada de saída.
Um modelo de RNA pode ser criado simplesmente chamando Sequential() API conforme especificado abaixo -
from keras.models import Sequential
model = Sequential()
Adicionar camadas
Para adicionar uma camada, basta criar uma camada usando a API de camada Keras e, em seguida, passar a camada através da função add () conforme especificado abaixo -
from keras.models import Sequential
model = Sequential()
input_layer = Dense(32, input_shape=(8,)) model.add(input_layer)
hidden_layer = Dense(64, activation='relu'); model.add(hidden_layer)
output_layer = Dense(8)
model.add(output_layer)
Aqui, criamos uma camada de entrada, uma camada oculta e uma camada de saída.
Acesse o modelo
Keras fornece alguns métodos para obter as informações do modelo, como camadas, dados de entrada e dados de saída. Eles são os seguintes -
model.layers - Retorna todas as camadas do modelo como lista.
>>> layers = model.layers
>>> layers
[
<keras.layers.core.Dense object at 0x000002C8C888B8D0>,
<keras.layers.core.Dense object at 0x000002C8C888B7B8>
<keras.layers.core.Dense object at 0x 000002C8C888B898>
]
model.inputs - Retorna todos os tensores de entrada do modelo como lista.
>>> inputs = model.inputs
>>> inputs
[<tf.Tensor 'dense_13_input:0' shape=(?, 8) dtype=float32>]
model.outputs - Retorna todos os tensores de saída do modelo como lista.
>>> outputs = model.outputs
>>> outputs
<tf.Tensor 'dense_15/BiasAdd:0' shape=(?, 8) dtype=float32>]
model.get_weights - Retorna todos os pesos como matrizes NumPy.
model.set_weights(weight_numpy_array) - Defina os pesos do modelo.
Serializar o modelo
Keras fornece métodos para serializar o modelo em objeto, bem como json e carregá-lo novamente mais tarde. Eles são os seguintes -
get_config() - IR retorna o modelo como um objeto.
config = model.get_config()
from_config() - Aceita o objeto de configuração do modelo como argumento e cria o modelo de acordo.
new_model = Sequential.from_config(config)
to_json() - Retorna o modelo como um objeto json.
>>> json_string = model.to_json()
>>> json_string '{"class_name": "Sequential", "config":
{"name": "sequential_10", "layers":
[{"class_name": "Dense", "config":
{"name": "dense_13", "trainable": true, "batch_input_shape":
[null, 8], "dtype": "float32", "units": 32, "activation": "linear",
"use_bias": true, "kernel_initializer":
{"class_name": "Vari anceScaling", "config":
{"scale": 1.0, "mode": "fan_avg", "distribution": "uniform", "seed": null}},
"bias_initializer": {"class_name": "Zeros", "conf
ig": {}}, "kernel_regularizer": null, "bias_regularizer": null,
"activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}},
{" class_name": "Dense", "config": {"name": "dense_14", "trainable": true,
"dtype": "float32", "units": 64, "activation": "relu", "use_bias": true,
"kern el_initializer": {"class_name": "VarianceScaling", "config":
{"scale": 1.0, "mode": "fan_avg", "distribution": "uniform", "seed": null}},
"bias_initia lizer": {"class_name": "Zeros",
"config": {}}, "kernel_regularizer": null, "bias_regularizer": null,
"activity_regularizer": null, "kernel_constraint" : null, "bias_constraint": null}},
{"class_name": "Dense", "config": {"name": "dense_15", "trainable": true,
"dtype": "float32", "units": 8, "activation": "linear", "use_bias": true,
"kernel_initializer": {"class_name": "VarianceScaling", "config":
{"scale": 1.0, "mode": "fan_avg", "distribution": " uniform", "seed": null}},
"bias_initializer": {"class_name": "Zeros", "config": {}},
"kernel_regularizer": null, "bias_regularizer": null, "activity_r egularizer":
null, "kernel_constraint": null, "bias_constraint":
null}}]}, "keras_version": "2.2.5", "backend": "tensorflow"}'
>>>
model_from_json() - Aceita a representação json do modelo e cria um novo modelo.
from keras.models import model_from_json
new_model = model_from_json(json_string)
to_yaml() - Retorna o modelo como uma string yaml.
>>> yaml_string = model.to_yaml()
>>> yaml_string 'backend: tensorflow\nclass_name:
Sequential\nconfig:\n layers:\n - class_name: Dense\n config:\n
activation: linear\n activity_regular izer: null\n batch_input_shape:
!!python/tuple\n - null\n - 8\n bias_constraint: null\n bias_initializer:\n
class_name : Zeros\n config: {}\n bias_regularizer: null\n dtype:
float32\n kernel_constraint: null\n
kernel_initializer:\n cla ss_name: VarianceScaling\n config:\n
distribution: uniform\n mode: fan_avg\n
scale: 1.0\n seed: null\n kernel_regularizer: null\n name: dense_13\n
trainable: true\n units: 32\n
use_bias: true\n - class_name: Dense\n config:\n activation: relu\n activity_regularizer: null\n
bias_constraint: null\n bias_initializer:\n class_name: Zeros\n
config : {}\n bias_regularizer: null\n dtype: float32\n
kernel_constraint: null\n kernel_initializer:\n class_name: VarianceScalin g\n
config:\n distribution: uniform\n mode: fan_avg\n scale: 1.0\n
seed: null\n kernel_regularizer: nu ll\n name: dense_14\n trainable: true\n
units: 64\n use_bias: true\n - class_name: Dense\n config:\n
activation: linear\n activity_regularizer: null\n
bias_constraint: null\n bias_initializer:\n
class_name: Zeros\n config: {}\n bias_regu larizer: null\n
dtype: float32\n kernel_constraint: null\n
kernel_initializer:\n class_name: VarianceScaling\n config:\n
distribution: uniform\n mode: fan_avg\n
scale: 1.0\n seed: null\n kernel_regularizer: null\n name: dense _15\n
trainable: true\n units: 8\n
use_bias: true\n name: sequential_10\nkeras_version: 2.2.5\n'
>>>
model_from_yaml() - Aceita a representação yaml do modelo e cria um novo modelo.
from keras.models import model_from_yaml
new_model = model_from_yaml(yaml_string)
Resuma o modelo
Entender o modelo é uma fase muito importante para usá-lo adequadamente para fins de treinamento e previsão. Keras fornece um método simples e resumido para obter todas as informações sobre o modelo e suas camadas.
Um resumo do modelo criado na seção anterior é o seguinte -
>>> model.summary() Model: "sequential_10"
_________________________________________________________________
Layer (type) Output Shape Param
#================================================================
dense_13 (Dense) (None, 32) 288
_________________________________________________________________
dense_14 (Dense) (None, 64) 2112
_________________________________________________________________
dense_15 (Dense) (None, 8) 520
=================================================================
Total params: 2,920
Trainable params: 2,920
Non-trainable params: 0
_________________________________________________________________
>>>
Treine e preveja o modelo
O modelo fornece funções para o processo de treinamento, avaliação e previsão. Eles são os seguintes -
compile - Configurar o processo de aprendizagem do modelo
fit - Treine o modelo usando os dados de treinamento
evaluate - Avalie o modelo usando os dados de teste
predict - Preveja os resultados para novas entradas.
API funcional
A API sequencial é usada para criar modelos camada por camada. API funcional é uma abordagem alternativa para a criação de modelos mais complexos. Modelo funcional, você pode definir várias entradas ou saídas que compartilham camadas. Primeiro, criamos uma instância para o modelo e nos conectamos às camadas para acessar a entrada e a saída do modelo. Esta seção explica resumidamente sobre o modelo funcional.
Crie um modelo
Importe uma camada de entrada usando o módulo abaixo -
>>> from keras.layers import Input
Agora, crie uma camada de entrada especificando a forma da dimensão de entrada para o modelo usando o código abaixo -
>>> data = Input(shape=(2,3))
Defina a camada para a entrada usando o módulo abaixo -
>>> from keras.layers import Dense
Adicione camada densa para a entrada usando a linha de código abaixo -
>>> layer = Dense(2)(data)
>>> print(layer)
Tensor("dense_1/add:0", shape =(?, 2, 2), dtype = float32)
Defina o modelo usando o módulo abaixo -
from keras.models import Model
Crie um modelo de maneira funcional, especificando a camada de entrada e saída -
model = Model(inputs = data, outputs = layer)
O código completo para criar um modelo simples é mostrado abaixo -
from keras.layers import Input
from keras.models import Model
from keras.layers import Dense
data = Input(shape=(2,3))
layer = Dense(2)(data) model =
Model(inputs=data,outputs=layer) model.summary()
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
input_2 (InputLayer) (None, 2, 3) 0
_________________________________________________________________
dense_2 (Dense) (None, 2, 2) 8
=================================================================
Total params: 8
Trainable params: 8
Non-trainable params: 0
_________________________________________________________________
Keras - compilação de modelos
Anteriormente, estudamos os fundamentos de como criar um modelo usando API Sequencial e Funcional. Este capítulo explica como compilar o modelo. A compilação é a etapa final na criação de um modelo. Assim que a compilação estiver concluída, podemos passar para a fase de treinamento.
Vamos aprender alguns conceitos necessários para entender melhor o processo de compilação.
Perda
No aprendizado de máquina, Lossfunção é usada para encontrar erros ou desvios no processo de aprendizagem. Keras requer função de perda durante o processo de compilação do modelo.
Keras fornece algumas funções de perda no losses módulo e eles são os seguintes -
- mean_squared_error
- mean_absolute_error
- mean_absolute_percentage_error
- mean_squared_logarithmic_error
- squared_hinge
- hinge
- categorical_hinge
- logcosh
- huber_loss
- categorical_crossentropy
- sparse_categorical_crossentropy
- binary_crossentropy
- kullback_leibler_divergence
- poisson
- cosine_proximity
- is_categorical_crossentropy
Todas as funções de perda acima aceitam dois argumentos -
y_true - rótulos verdadeiros como tensores
y_pred - previsão com a mesma forma que y_true
Importe o módulo de perdas antes de usar a função de perda conforme especificado abaixo -
from keras import losses
Otimizador
No aprendizado de máquina, Optimizationé um processo importante que otimiza os pesos de entrada comparando a previsão e a função de perda. Keras fornece alguns otimizadores como módulo, otimizadores e eles são os seguintes:
SGD - Otimizador de descida gradiente estocástico.
keras.optimizers.SGD(learning_rate = 0.01, momentum = 0.0, nesterov = False)
RMSprop - Otimizador RMSProp.
keras.optimizers.RMSprop(learning_rate = 0.001, rho = 0.9)
Adagrad - Otimizador Adagrad.
keras.optimizers.Adagrad(learning_rate = 0.01)
Adadelta - Otimizador Adadelta.
keras.optimizers.Adadelta(learning_rate = 1.0, rho = 0.95)
Adam - Otimizador Adam.
keras.optimizers.Adam(
learning_rate = 0.001, beta_1 = 0.9, beta_2 = 0.999, amsgrad = False
)
Adamax - Otimizador Adamax de Adam.
keras.optimizers.Adamax(learning_rate = 0.002, beta_1 = 0.9, beta_2 = 0.999)
Nadam - Otimizador Nesterov Adam.
keras.optimizers.Nadam(learning_rate = 0.002, beta_1 = 0.9, beta_2 = 0.999)
Importe o módulo otimizadores antes de usar otimizadores conforme especificado abaixo -
from keras import optimizers
Métricas
No aprendizado de máquina, Metricsé usado para avaliar o desempenho do seu modelo. É semelhante à função de perda, mas não é usado no processo de treinamento. Keras fornece algumas métricas como um módulo,metrics e eles são os seguintes
- accuracy
- binary_accuracy
- categorical_accuracy
- sparse_categorical_accuracy
- top_k_categorical_accuracy
- sparse_top_k_categorical_accuracy
- cosine_proximity
- clone_metric
Semelhante à função de perda, as métricas também aceitam os dois argumentos abaixo -
y_true - rótulos verdadeiros como tensores
y_pred - previsão com a mesma forma que y_true
Importe o módulo de métricas antes de usar métricas conforme especificado abaixo -
from keras import metrics
Compile o modelo
O modelo Keras fornece um método, compile()para compilar o modelo. O argumento e o valor padrão docompile() método é o seguinte
compile(
optimizer,
loss = None,
metrics = None,
loss_weights = None,
sample_weight_mode = None,
weighted_metrics = None,
target_tensors = None
)
Os argumentos importantes são os seguintes -
- função de perda
- Optimizer
- metrics
Um exemplo de código para compilar o modo é o seguinte -
from keras import losses
from keras import optimizers
from keras import metrics
model.compile(loss = 'mean_squared_error',
optimizer = 'sgd', metrics = [metrics.categorical_accuracy])
Onde,
função de perda é definida como mean_squared_error
otimizador está definido como sgd
métricas é definido como metrics.categorical_accuracy
Treinamento de modelo
Os modelos são treinados por matrizes NumPy usando fit(). O objetivo principal desta função de ajuste é usado para avaliar seu modelo no treinamento. Isso também pode ser usado para representar graficamente o desempenho do modelo. Possui a seguinte sintaxe -
model.fit(X, y, epochs = , batch_size = )
Aqui,
X, y - É uma tupla para avaliar seus dados.
epochs - nenhuma vez o modelo precisa ser avaliado durante o treinamento.
batch_size - instâncias de treinamento.
Vamos dar um exemplo simples de dados aleatórios numpy para usar esse conceito.
Criar dados
Vamos criar um dado aleatório usando numpy para xey com a ajuda do comando mencionado abaixo -
import numpy as np
x_train = np.random.random((100,4,8))
y_train = np.random.random((100,10))
Agora, crie dados de validação aleatórios,
x_val = np.random.random((100,4,8))
y_val = np.random.random((100,10))
Criar modelo
Vamos criar um modelo sequencial simples -
from keras.models import Sequential model = Sequential()
Adicionar camadas
Crie camadas para adicionar modelo -
from keras.layers import LSTM, Dense
# add a sequence of vectors of dimension 16
model.add(LSTM(16, return_sequences = True))
model.add(Dense(10, activation = 'softmax'))
modelo de compilação
Agora o modelo está definido. Você pode compilar usando o comando abaixo -
model.compile(
loss = 'categorical_crossentropy', optimizer = 'sgd', metrics = ['accuracy']
)
Aplicar ajuste ()
Agora aplicamos a função fit () para treinar nossos dados -
model.fit(x_train, y_train, batch_size = 32, epochs = 5, validation_data = (x_val, y_val))
Criar uma RNA Perceptron Multi-Camada
Aprendemos a criar, compilar e treinar os modelos Keras.
Vamos aplicar nosso aprendizado e criar uma RNA simples baseada em MPL.
Módulo de conjunto de dados
Antes de criar um modelo, precisamos escolher um problema, precisamos coletar os dados necessários e converter os dados para a matriz NumPy. Depois que os dados são coletados, podemos preparar o modelo e treiná-lo usando os dados coletados. A coleta de dados é uma das fases mais difíceis do aprendizado de máquina. Keras fornece um módulo especial, conjuntos de dados para baixar os dados de aprendizado de máquina online para fins de treinamento. Ele busca os dados do servidor online, processa os dados e retorna os dados como um conjunto de treinamento e teste. Vamos verificar os dados fornecidos pelo módulo de conjunto de dados Keras. Os dados disponíveis no módulo são os seguintes,
- Classificação de imagem pequena CIFAR10
- Classificação de imagens pequenas CIFAR100
- IMDB filme analisa a classificação de sentimento
- Classificação de tópicos de notícias da Reuters
- Banco de dados MNIST de dígitos manuscritos
- Banco de dados de artigos de moda Fashion-MNIST
- Conjunto de dados de regressão de preços de habitação em Boston
Vamos usar o MNIST database of handwritten digits(ou minst) como nossa entrada. minst é uma coleção de 60.000 imagens em tons de cinza de 28x28. Ele contém 10 dígitos. Ele também contém 10.000 imagens de teste.
O código abaixo pode ser usado para carregar o conjunto de dados -
from keras.datasets import mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
Onde
Line 1 importações minst do módulo de conjunto de dados keras.
Line 3 chama o load_data função, que irá buscar os dados do servidor online e retornar os dados como 2 tuplas, Primeira tupla, (x_train, y_train) representam os dados de treinamento com forma, (number_sample, 28, 28) e seu rótulo de dígito com forma, (number_samples, ). Segunda tupla,(x_test, y_test) representam dados de teste com a mesma forma.
Outro conjunto de dados também pode ser obtido usando API semelhante e cada API retorna dados semelhantes, exceto a forma dos dados. A forma dos dados depende do tipo de dados.
Crie um modelo
Vamos escolher um perceptron multicamadas simples (MLP) como representado abaixo e tentar criar o modelo usando Keras.
As principais características do modelo são as seguintes -
A camada de entrada consiste em 784 valores (28 x 28 = 784).
Primeira camada oculta, Dense consiste em 512 neurônios e função de ativação 'relu'.
Segunda camada oculta, Dropout tem 0,2 como valor.
Terceira camada oculta, novamente Densa consiste em 512 neurônios e função de ativação 'relu'.
Quarta camada oculta, Dropout tem 0,2 como valor.
A quinta e última camada consiste em 10 neurônios e função de ativação 'softmax'.
Usar categorical_crossentropy como função de perda.
Usar RMSprop() como otimizador.
Usar accuracy como métricas.
Use 128 como tamanho do lote.
Use 20 como épocas.
Step 1 − Import the modules
Deixe-nos importar os módulos necessários.
import keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout
from keras.optimizers import RMSprop
import numpy as np
Step 2 − Load data
Vamos importar o conjunto de dados mnist.
(x_train, y_train), (x_test, y_test) = mnist.load_data()
Step 3 − Process the data
Vamos alterar o conjunto de dados de acordo com nosso modelo, para que possa ser alimentado em nosso modelo.
x_train = x_train.reshape(60000, 784)
x_test = x_test.reshape(10000, 784)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
y_train = keras.utils.to_categorical(y_train, 10)
y_test = keras.utils.to_categorical(y_test, 10)
Onde
reshape é usado para remodelar a entrada da tupla (28, 28) para (784,)
to_categorical é usado para converter vetor em matriz binária
Step 4 − Create the model
Vamos criar o modelo real.
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,)))
model.add(Dropout(0.2))
model.add(Dense(512, activation = 'relu'))
model.add(Dropout(0.2))
model.add(Dense(10, activation = 'softmax'))
Step 5 − Compile the model
Vamos compilar o modelo usando a função de perda, otimizador e métricas selecionadas.
model.compile(loss = 'categorical_crossentropy',
optimizer = RMSprop(),
metrics = ['accuracy'])
Step 6 − Train the model
Vamos treinar o modelo usando fit() método.
history = model.fit(
x_train, y_train,
batch_size = 128,
epochs = 20,
verbose = 1,
validation_data = (x_test, y_test)
)
Pensamentos finais
Criamos o modelo, carregamos os dados e também treinamos os dados para o modelo. Ainda precisamos avaliar o modelo e prever a saída para entradas desconhecidas, que aprenderemos no próximo capítulo.
import keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout
from keras.optimizers import RMSprop
import numpy as np
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train.reshape(60000, 784)
x_test = x_test.reshape(10000, 784)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
y_train = keras.utils.to_categorical(y_train, 10)
y_test = keras.utils.to_categorical(y_test, 10)
model = Sequential()
model.add(Dense(512, activation='relu', input_shape = (784,)))
model.add(Dropout(0.2))
model.add(Dense(512, activation = 'relu')) model.add(Dropout(0.2))
model.add(Dense(10, activation = 'softmax'))
model.compile(loss = 'categorical_crossentropy',
optimizer = RMSprop(),
metrics = ['accuracy'])
history = model.fit(x_train, y_train,
batch_size = 128, epochs = 20, verbose = 1, validation_data = (x_test, y_test))
Executar o aplicativo fornecerá o conteúdo abaixo como saída -
Train on 60000 samples, validate on 10000 samples Epoch 1/20
60000/60000 [==============================] - 7s 118us/step - loss: 0.2453
- acc: 0.9236 - val_loss: 0.1004 - val_acc: 0.9675 Epoch 2/20
60000/60000 [==============================] - 7s 110us/step - loss: 0.1023
- acc: 0.9693 - val_loss: 0.0797 - val_acc: 0.9761 Epoch 3/20
60000/60000 [==============================] - 7s 110us/step - loss: 0.0744
- acc: 0.9770 - val_loss: 0.0727 - val_acc: 0.9791 Epoch 4/20
60000/60000 [==============================] - 7s 110us/step - loss: 0.0599
- acc: 0.9823 - val_loss: 0.0704 - val_acc: 0.9801 Epoch 5/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0504
- acc: 0.9853 - val_loss: 0.0714 - val_acc: 0.9817 Epoch 6/20
60000/60000 [==============================] - 7s 111us/step - loss: 0.0438
- acc: 0.9868 - val_loss: 0.0845 - val_acc: 0.9809 Epoch 7/20
60000/60000 [==============================] - 7s 114us/step - loss: 0.0391
- acc: 0.9887 - val_loss: 0.0823 - val_acc: 0.9802 Epoch 8/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0364
- acc: 0.9892 - val_loss: 0.0818 - val_acc: 0.9830 Epoch 9/20
60000/60000 [==============================] - 7s 113us/step - loss: 0.0308
- acc: 0.9905 - val_loss: 0.0833 - val_acc: 0.9829 Epoch 10/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0289
- acc: 0.9917 - val_loss: 0.0947 - val_acc: 0.9815 Epoch 11/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0279
- acc: 0.9921 - val_loss: 0.0818 - val_acc: 0.9831 Epoch 12/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0260
- acc: 0.9927 - val_loss: 0.0945 - val_acc: 0.9819 Epoch 13/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0257
- acc: 0.9931 - val_loss: 0.0952 - val_acc: 0.9836 Epoch 14/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0229
- acc: 0.9937 - val_loss: 0.0924 - val_acc: 0.9832 Epoch 15/20
60000/60000 [==============================] - 7s 115us/step - loss: 0.0235
- acc: 0.9937 - val_loss: 0.1004 - val_acc: 0.9823 Epoch 16/20
60000/60000 [==============================] - 7s 113us/step - loss: 0.0214
- acc: 0.9941 - val_loss: 0.0991 - val_acc: 0.9847 Epoch 17/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0219
- acc: 0.9943 - val_loss: 0.1044 - val_acc: 0.9837 Epoch 18/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0190
- acc: 0.9952 - val_loss: 0.1129 - val_acc: 0.9836 Epoch 19/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0197
- acc: 0.9953 - val_loss: 0.0981 - val_acc: 0.9841 Epoch 20/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0198
- acc: 0.9950 - val_loss: 0.1215 - val_acc: 0.9828
Keras - Avaliação e previsão do modelo
Este capítulo trata da avaliação e predição do modelo em Keras.
Vamos começar entendendo a avaliação do modelo.
Avaliação de modelo
A avaliação é um processo durante o desenvolvimento do modelo para verificar se o modelo é o mais adequado para o problema fornecido e os dados correspondentes. O modelo Keras fornece uma função, avalia que faz a avaliação do modelo. Tem três argumentos principais,
- Dados de teste
- Etiqueta de dados de teste
- verboso - verdadeiro ou falso
Vamos avaliar o modelo, que criamos no capítulo anterior usando dados de teste.
score = model.evaluate(x_test, y_test, verbose = 0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
Executar o código acima resultará nas informações abaixo.
0
A precisão do teste é de 98,28%. Criamos o melhor modelo para identificar os dígitos da escrita. Do lado positivo, ainda podemos melhorar nosso modelo.
Predição de modelo
Predictioné a etapa final e nosso resultado esperado da geração do modelo. Keras fornece um método de previsão para obter a previsão do modelo treinado. A assinatura do método de previsão é a seguinte,
predict(
x,
batch_size = None,
verbose = 0,
steps = None,
callbacks = None,
max_queue_size = 10,
workers = 1,
use_multiprocessing = False
)
Aqui, todos os argumentos são opcionais, exceto o primeiro argumento, que se refere aos dados de entrada desconhecidos. A forma deve ser mantida para obter a previsão adequada.
Vamos fazer uma previsão para o nosso modelo MPL criado no capítulo anterior usando o código abaixo -
pred = model.predict(x_test)
pred = np.argmax(pred, axis = 1)[:5]
label = np.argmax(y_test,axis = 1)[:5]
print(pred)
print(label)
Aqui,
Line 1 chamar a função de previsão usando dados de teste.
Line 2 obtém as cinco primeiras previsões
Line 3 obtém os primeiros cinco rótulos dos dados de teste.
Line 5 - 6 imprime a previsão e o rótulo real.
O resultado do aplicativo acima é o seguinte -
[7 2 1 0 4]
[7 2 1 0 4]
A saída de ambas as matrizes é idêntica e indica que nosso modelo prediz corretamente as primeiras cinco imagens.
Keras - Rede Neural de Convolução
Vamos modificar o modelo de MPL para Convolution Neural Network (CNN) para nosso problema anterior de identificação de dígitos.
CNN pode ser representada como abaixo -
As principais características do modelo são as seguintes -
A camada de entrada consiste em (1, 8, 28) valores.
Primeira camada, Conv2D consiste em 32 filtros e função de ativação 'relu' com tamanho de kernel, (3,3).
Segunda camada, Conv2D consiste em 64 filtros e função de ativação 'relu' com tamanho de kernel, (3,3).
Terceira camada, MaxPooling tem tamanho de piscina de (2, 2).
Quinta camada, Flatten é usado para nivelar todas as suas entradas em uma única dimensão.
Sexta camada, Dense consiste em 128 neurônios e função de ativação 'relu'.
Sétima camada, Dropout tem 0,5 como valor.
A oitava e última camada consiste em 10 neurônios e função de ativação 'softmax'.
Usar categorical_crossentropy como função de perda.
Usar Adadelta() como otimizador.
Usar accuracy como métricas.
Use 128 como tamanho do lote.
Use 20 como épocas.
Step 1 − Import the modules
Deixe-nos importar os módulos necessários.
import keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras import backend as K
import numpy as np
Step 2 − Load data
Vamos importar o conjunto de dados mnist.
(x_train, y_train), (x_test, y_test) = mnist.load_data()
Step 3 − Process the data
Vamos alterar o conjunto de dados de acordo com nosso modelo, para que possa ser alimentado em nosso modelo.
img_rows, img_cols = 28, 28
if K.image_data_format() == 'channels_first':
x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols)
x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)
input_shape = (1, img_rows, img_cols)
else:
x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)
x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)
input_shape = (img_rows, img_cols, 1)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
y_train = keras.utils.to_categorical(y_train, 10)
y_test = keras.utils.to_categorical(y_test, 10)
O processamento de dados é semelhante ao modelo MPL, exceto a forma dos dados de entrada e a configuração do formato de imagem.
Step 4 − Create the model
Vamos criar o modelo real.
model = Sequential()
model.add(Conv2D(32, kernel_size = (3, 3),
activation = 'relu', input_shape = input_shape))
model.add(Conv2D(64, (3, 3), activation = 'relu'))
model.add(MaxPooling2D(pool_size = (2, 2)))
model.add(Dropout(0.25)) model.add(Flatten())
model.add(Dense(128, activation = 'relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation = 'softmax'))
Step 5 − Compile the model
Vamos compilar o modelo usando a função de perda, otimizador e métricas selecionadas.
model.compile(loss = keras.losses.categorical_crossentropy,
optimizer = keras.optimizers.Adadelta(), metrics = ['accuracy'])
Step 6 − Train the model
Vamos treinar o modelo usando fit() método.
model.fit(
x_train, y_train,
batch_size = 128,
epochs = 12,
verbose = 1,
validation_data = (x_test, y_test)
)
Executar o aplicativo irá gerar as informações abaixo -
Train on 60000 samples, validate on 10000 samples Epoch 1/12
60000/60000 [==============================] - 84s 1ms/step - loss: 0.2687
- acc: 0.9173 - val_loss: 0.0549 - val_acc: 0.9827 Epoch 2/12
60000/60000 [==============================] - 86s 1ms/step - loss: 0.0899
- acc: 0.9737 - val_loss: 0.0452 - val_acc: 0.9845 Epoch 3/12
60000/60000 [==============================] - 83s 1ms/step - loss: 0.0666
- acc: 0.9804 - val_loss: 0.0362 - val_acc: 0.9879 Epoch 4/12
60000/60000 [==============================] - 81s 1ms/step - loss: 0.0564
- acc: 0.9830 - val_loss: 0.0336 - val_acc: 0.9890 Epoch 5/12
60000/60000 [==============================] - 86s 1ms/step - loss: 0.0472
- acc: 0.9861 - val_loss: 0.0312 - val_acc: 0.9901 Epoch 6/12
60000/60000 [==============================] - 83s 1ms/step - loss: 0.0414
- acc: 0.9877 - val_loss: 0.0306 - val_acc: 0.9902 Epoch 7/12
60000/60000 [==============================] - 89s 1ms/step - loss: 0.0375
-acc: 0.9883 - val_loss: 0.0281 - val_acc: 0.9906 Epoch 8/12
60000/60000 [==============================] - 91s 2ms/step - loss: 0.0339
- acc: 0.9893 - val_loss: 0.0280 - val_acc: 0.9912 Epoch 9/12
60000/60000 [==============================] - 89s 1ms/step - loss: 0.0325
- acc: 0.9901 - val_loss: 0.0260 - val_acc: 0.9909 Epoch 10/12
60000/60000 [==============================] - 89s 1ms/step - loss: 0.0284
- acc: 0.9910 - val_loss: 0.0250 - val_acc: 0.9919 Epoch 11/12
60000/60000 [==============================] - 86s 1ms/step - loss: 0.0287
- acc: 0.9907 - val_loss: 0.0264 - val_acc: 0.9916 Epoch 12/12
60000/60000 [==============================] - 86s 1ms/step - loss: 0.0265
- acc: 0.9920 - val_loss: 0.0249 - val_acc: 0.9922
Step 7 − Evaluate the model
Vamos avaliar o modelo usando dados de teste.
score = model.evaluate(x_test, y_test, verbose = 0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
Executar o código acima resultará nas informações abaixo -
Test loss: 0.024936060590433316
Test accuracy: 0.9922
A precisão do teste é de 99,22%. Criamos o melhor modelo para identificar os dígitos da escrita.
Step 8 − Predict
Finalmente, preveja o dígito das imagens como abaixo -
pred = model.predict(x_test)
pred = np.argmax(pred, axis = 1)[:5]
label = np.argmax(y_test,axis = 1)[:5]
print(pred)
print(label)
O resultado do aplicativo acima é o seguinte -
[7 2 1 0 4]
[7 2 1 0 4]
A saída de ambas as matrizes é idêntica e indica que nosso modelo prevê corretamente as cinco primeiras imagens.
Keras - Predição de regressão usando MPL
Neste capítulo, vamos escrever uma RNA simples baseada em MPL para fazer a previsão de regressão. Até agora, fizemos apenas a previsão baseada na classificação. Agora, tentaremos prever o próximo valor possível, analisando os valores anteriores (contínuos) e seus fatores de influência.
O MPL de regressão pode ser representado como abaixo -
As principais características do modelo são as seguintes -
A camada de entrada consiste em (13,) valores.
Primeira camada, Dense consiste em 64 unidades e função de ativação 'relu' com inicializador de kernel 'normal'.
Segunda camada, Denso consiste em 64 unidades e função de ativação 'relu'.
Camada de saída, Densa consiste em 1 unidade.
Usar mse como função de perda.
Usar RMSprop como otimizador.
Usar accuracy como métricas.
Use 128 como tamanho do lote.
Use 500 como épocas.
Step 1 − Import the modules
Deixe-nos importar os módulos necessários.
import keras
from keras.datasets import boston_housing
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import RMSprop
from keras.callbacks import EarlyStopping
from sklearn import preprocessing
from sklearn.preprocessing import scale
Step 2 − Load data
Vamos importar o conjunto de dados de habitação de Boston.
(x_train, y_train), (x_test, y_test) = boston_housing.load_data()
Aqui,
boston_housingé um conjunto de dados fornecido por Keras. Ele representa uma coleção de informações sobre moradias na área de Boston, cada uma com 13 recursos.
Step 3 − Process the data
Vamos mudar o conjunto de dados de acordo com nosso modelo, para que possamos alimentar nosso modelo. Os dados podem ser alterados usando o código abaixo -
x_train_scaled = preprocessing.scale(x_train)
scaler = preprocessing.StandardScaler().fit(x_train)
x_test_scaled = scaler.transform(x_test)
Aqui, normalizamos os dados de treinamento usando sklearn.preprocessing.scale função. preprocessing.StandardScaler().fit função retorna um escalar com a média normalizada e o desvio padrão dos dados de treinamento, que podemos aplicar aos dados de teste usando scalar.transformfunção. Isso normalizará os dados de teste também com a mesma configuração dos dados de treinamento.
Step 4 − Create the model
Vamos criar o modelo real.
model = Sequential()
model.add(Dense(64, kernel_initializer = 'normal', activation = 'relu',
input_shape = (13,)))
model.add(Dense(64, activation = 'relu')) model.add(Dense(1))
Step 5 − Compile the model
Vamos compilar o modelo usando a função de perda, otimizador e métricas selecionadas.
model.compile(
loss = 'mse',
optimizer = RMSprop(),
metrics = ['mean_absolute_error']
)
Step 6 − Train the model
Vamos treinar o modelo usando fit() método.
history = model.fit(
x_train_scaled, y_train,
batch_size=128,
epochs = 500,
verbose = 1,
validation_split = 0.2,
callbacks = [EarlyStopping(monitor = 'val_loss', patience = 20)]
)
Aqui, usamos a função de retorno de chamada, EarlyStopping. O objetivo deste retorno de chamada é monitorar o valor da perda durante cada época e compará-lo com o valor da perda da época anterior para encontrar a melhoria no treinamento. Se não houver melhora para opatience vezes, então todo o processo será interrompido.
Executar o aplicativo fornecerá as informações abaixo como saída -
Train on 323 samples, validate on 81 samples Epoch 1/500 2019-09-24 01:07:03.889046: I
tensorflow/core/platform/cpu_feature_guard.cc:142]
Your CPU supports instructions that this
TensorFlow binary was not co mpiled to use: AVX2 323/323
[==============================] - 0s 515us/step - loss: 562.3129
- mean_absolute_error: 21.8575 - val_loss: 621.6523 - val_mean_absolute_erro
r: 23.1730 Epoch 2/500
323/323 [==============================] - 0s 11us/step - loss: 545.1666
- mean_absolute_error: 21.4887 - val_loss: 605.1341 - val_mean_absolute_error
: 22.8293 Epoch 3/500
323/323 [==============================] - 0s 12us/step - loss: 528.9944
- mean_absolute_error: 21.1328 - val_loss: 588.6594 - val_mean_absolute_error
: 22.4799 Epoch 4/500
323/323 [==============================] - 0s 12us/step - loss: 512.2739
- mean_absolute_error: 20.7658 - val_loss: 570.3772 - val_mean_absolute_error
: 22.0853 Epoch 5/500
323/323 [==============================] - 0s 9us/step - loss: 493.9775
- mean_absolute_error: 20.3506 - val_loss: 550.9548 - val_mean_absolute_error: 21.6547
..........
..........
..........
Epoch 143/500
323/323 [==============================] - 0s 15us/step - loss: 8.1004
- mean_absolute_error: 2.0002 - val_loss: 14.6286 - val_mean_absolute_error:
2. 5904 Epoch 144/500
323/323 [==============================] - 0s 19us/step - loss: 8.0300
- mean_absolute_error: 1.9683 - val_loss: 14.5949 - val_mean_absolute_error:
2. 5843 Epoch 145/500
323/323 [==============================] - 0s 12us/step - loss: 7.8704
- mean_absolute_error: 1.9313 - val_loss: 14.3770 - val_mean_absolute_error: 2. 4996
Step 7 − Evaluate the model
Vamos avaliar o modelo usando dados de teste.
score = model.evaluate(x_test_scaled, y_test, verbose = 0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
Executar o código acima resultará nas informações abaixo -
Test loss: 21.928471583946077 Test accuracy: 2.9599233234629914
Step 8 − Predict
Finalmente, preveja usando dados de teste como abaixo -
prediction = model.predict(x_test_scaled)
print(prediction.flatten())
print(y_test)
O resultado do aplicativo acima é o seguinte -
[ 7.5612316 17.583357 21.09344 31.859276 25.055613 18.673872 26.600405 22.403967 19.060272 22.264952
17.4191 17.00466 15.58924 41.624374 20.220217 18.985565 26.419338 19.837091 19.946192 36.43445
12.278508 16.330965 20.701359 14.345301 21.741161 25.050423 31.046402 27.738455 9.959419 20.93039
20.069063 14.518344 33.20235 24.735163 18.7274 9.148898 15.781284 18.556862 18.692865 26.045074
27.954073 28.106823 15.272034 40.879818 29.33896 23.714525 26.427515 16.483374 22.518442 22.425386
33.94826 18.831465 13.2501955 15.537227 34.639984 27.468002 13.474407 48.134598 34.39617
22.8503124.042334 17.747198 14.7837715 18.187277 23.655672 22.364983 13.858193 22.710032 14.371148
7.1272087 35.960033 28.247292 25.3014 14.477208 25.306196 17.891165 20.193708 23.585173 34.690193
12.200583 20.102983 38.45882 14.741723 14.408362 17.67158 18.418497 21.151712 21.157492 22.693687
29.809034 19.366991 20.072294 25.880817 40.814568 34.64087 19.43741 36.2591 50.73806 26.968863 43.91787
32.54908 20.248306 ] [ 7.2 18.8 19. 27. 22.2 24.5 31.2 22.9 20.5 23.2 18.6 14.5 17.8 50. 20.8 24.3 24.2
19.8 19.1 22.7 12. 10.2 20. 18.5 20.9 23. 27.5 30.1 9.5 22. 21.2 14.1 33.1 23.4 20.1 7.4 15.4 23.8 20.1
24.5 33. 28.4 14.1 46.7 32.5 29.6 28.4 19.8 20.2 25. 35.4 20.3 9.7 14.5 34.9 26.6 7.2 50. 32.4 21.6 29.8
13.1 27.5 21.2 23.1 21.9 13. 23.2 8.1 5.6 21.7 29.6 19.6 7. 26.4 18.9 20.9 28.1 35.4 10.2 24.3 43.1 17.6
15.4 16.2 27.1 21.4 21.5 22.4 25. 16.6 18.6 22. 42.8 35.1 21.5 36. 21.9 24.1 50. 26.7 25. ]
A saída de ambas as matrizes tem cerca de 10-30% de diferença e indica que nosso modelo prevê com uma faixa razoável.
Keras - Previsão de série temporal usando LSTM RNN
Neste capítulo, vamos escrever um RNN simples baseado em Long Short Term Memory (LSTM) para fazer análise de sequência. Uma sequência é um conjunto de valores onde cada valor corresponde a uma instância particular de tempo. Vamos considerar um exemplo simples de leitura de uma frase. Ler e entender uma frase envolve ler a palavra na ordem dada e tentar entender cada palavra e seu significado no contexto dado e, finalmente, entender a frase em um sentimento positivo ou negativo.
Aqui, as palavras são consideradas como valores, e o primeiro valor corresponde à primeira palavra, o segundo valor corresponde à segunda palavra, etc., e a ordem será estritamente mantida. Sequence Analysis é usado com frequência no processamento de linguagem natural para encontrar a análise de sentimento do texto fornecido.
Vamos criar um modelo LSTM para analisar as resenhas de filmes IMDB e encontrar seu sentimento positivo / negativo.
O modelo para a análise da sequência pode ser representado como abaixo -
As principais características do modelo são as seguintes -
Camada de entrada usando a camada Embedding com 128 recursos.
A primeira camada, Densa, consiste em 128 unidades com dropout normal e dropout recorrente definido como 0,2.
Camada de saída, Densa consiste em 1 unidade e função de ativação 'sigmóide'.
Usar binary_crossentropy como função de perda.
Usar adam como otimizador.
Usar accuracy como métricas.
Use 32 como tamanho do lote.
Use 15 como épocas.
Use 80 como o comprimento máximo da palavra.
Use 2000 como o número máximo de palavras em uma determinada frase.
Etapa 1: importar os módulos
Deixe-nos importar os módulos necessários.
from keras.preprocessing import sequence
from keras.models import Sequential
from keras.layers import Dense, Embedding
from keras.layers import LSTM
from keras.datasets import imdb
Etapa 2: Carregar dados
Vamos importar o conjunto de dados imdb.
(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words = 2000)
Aqui,
imdbé um conjunto de dados fornecido por Keras. Ele representa uma coleção de filmes e suas críticas.
num_words representam o número máximo de palavras na revisão.
Etapa 3: processar os dados
Vamos alterar o conjunto de dados de acordo com nosso modelo, para que possa ser alimentado em nosso modelo. Os dados podem ser alterados usando o código abaixo -
x_train = sequence.pad_sequences(x_train, maxlen=80)
x_test = sequence.pad_sequences(x_test, maxlen=80)
Aqui,
sequence.pad_sequences converter a lista de dados de entrada com forma, (data) em matriz NumPy 2D de forma (data, timesteps). Basicamente, ele adiciona o conceito de passos de tempo aos dados fornecidos. Ele gera os passos de tempo de duração,maxlen.
Etapa 4: crie o modelo
Vamos criar o modelo real.
model = Sequential()
model.add(Embedding(2000, 128))
model.add(LSTM(128, dropout = 0.2, recurrent_dropout = 0.2))
model.add(Dense(1, activation = 'sigmoid'))
Aqui,
Nós usamos Embedding layercomo camada de entrada e depois adicionada a camada LSTM. Finalmente, umDense layer é usado como camada de saída.
Etapa 5: compilar o modelo
Vamos compilar o modelo usando a função de perda, otimizador e métricas selecionadas.
model.compile(loss = 'binary_crossentropy',
optimizer = 'adam', metrics = ['accuracy'])
Etapa 6: treinar o modelo
Vamos treinar o modelo usando fit() método.
model.fit(
x_train, y_train,
batch_size = 32,
epochs = 15,
validation_data = (x_test, y_test)
)
Executar o aplicativo irá gerar as informações abaixo -
Epoch 1/15 2019-09-24 01:19:01.151247: I
tensorflow/core/platform/cpu_feature_guard.cc:142]
Your CPU supports instructions that this
TensorFlow binary was not co mpiled to use: AVX2
25000/25000 [==============================] - 101s 4ms/step - loss: 0.4707
- acc: 0.7716 - val_loss: 0.3769 - val_acc: 0.8349 Epoch 2/15
25000/25000 [==============================] - 95s 4ms/step - loss: 0.3058
- acc: 0.8756 - val_loss: 0.3763 - val_acc: 0.8350 Epoch 3/15
25000/25000 [==============================] - 91s 4ms/step - loss: 0.2100
- acc: 0.9178 - val_loss: 0.5065 - val_acc: 0.8110 Epoch 4/15
25000/25000 [==============================] - 90s 4ms/step - loss: 0.1394
- acc: 0.9495 - val_loss: 0.6046 - val_acc: 0.8146 Epoch 5/15
25000/25000 [==============================] - 90s 4ms/step - loss: 0.0973
- acc: 0.9652 - val_loss: 0.5969 - val_acc: 0.8147 Epoch 6/15
25000/25000 [==============================] - 98s 4ms/step - loss: 0.0759
- acc: 0.9730 - val_loss: 0.6368 - val_acc: 0.8208 Epoch 7/15
25000/25000 [==============================] - 95s 4ms/step - loss: 0.0578
- acc: 0.9811 - val_loss: 0.6657 - val_acc: 0.8184 Epoch 8/15
25000/25000 [==============================] - 97s 4ms/step - loss: 0.0448
- acc: 0.9850 - val_loss: 0.7452 - val_acc: 0.8136 Epoch 9/15
25000/25000 [==============================] - 95s 4ms/step - loss: 0.0324
- acc: 0.9894 - val_loss: 0.7616 - val_acc: 0.8162Epoch 10/15
25000/25000 [==============================] - 100s 4ms/step - loss: 0.0247
- acc: 0.9922 - val_loss: 0.9654 - val_acc: 0.8148 Epoch 11/15
25000/25000 [==============================] - 99s 4ms/step - loss: 0.0169
- acc: 0.9946 - val_loss: 1.0013 - val_acc: 0.8104 Epoch 12/15
25000/25000 [==============================] - 90s 4ms/step - loss: 0.0154
- acc: 0.9948 - val_loss: 1.0316 - val_acc: 0.8100 Epoch 13/15
25000/25000 [==============================] - 89s 4ms/step - loss: 0.0113
- acc: 0.9963 - val_loss: 1.1138 - val_acc: 0.8108 Epoch 14/15
25000/25000 [==============================] - 89s 4ms/step - loss: 0.0106
- acc: 0.9971 - val_loss: 1.0538 - val_acc: 0.8102 Epoch 15/15
25000/25000 [==============================] - 89s 4ms/step - loss: 0.0090
- acc: 0.9972 - val_loss: 1.1453 - val_acc: 0.8129
25000/25000 [==============================] - 10s 390us/step
Etapa 7 - Avalie o modelo
Vamos avaliar o modelo usando dados de teste.
score, acc = model.evaluate(x_test, y_test, batch_size = 32)
print('Test score:', score)
print('Test accuracy:', acc)
Executar o código acima resultará nas informações abaixo -
Test score: 1.145306069601178
Test accuracy: 0.81292
Keras - Aplicativos
O módulo de aplicativos Keras é usado para fornecer um modelo pré-treinado para redes neurais profundas. Os modelos Keras são usados para previsão, extração de recursos e ajuste fino. Este capítulo explica detalhadamente os aplicativos Keras.
Modelos pré-treinados
O modelo treinado consiste em duas partes da arquitetura do modelo e dos pesos do modelo. Pesos de modelo são arquivos grandes, então temos que baixar e extrair o recurso do banco de dados ImageNet. Alguns dos modelos pré-treinados populares estão listados abaixo,
- ResNet
- VGG16
- MobileNet
- InceptionResNetV2
- InceptionV3
Carregando um modelo
Os modelos pré-treinados Keras podem ser carregados facilmente conforme especificado abaixo -
import keras
import numpy as np
from keras.applications import vgg16, inception_v3, resnet50, mobilenet
#Load the VGG model
vgg_model = vgg16.VGG16(weights = 'imagenet')
#Load the Inception_V3 model
inception_model = inception_v3.InceptionV3(weights = 'imagenet')
#Load the ResNet50 model
resnet_model = resnet50.ResNet50(weights = 'imagenet')
#Load the MobileNet model mobilenet_model = mobilenet.MobileNet(weights = 'imagenet')
Depois que o modelo é carregado, podemos usá-lo imediatamente para fins de previsão. Vamos verificar cada modelo pré-treinado nos próximos capítulos.
Predição em tempo real usando modelo ResNet
ResNet é um modelo pré-treinado. Ele é treinado usando ImageNet . O modelo ResNet pondera pré-treinado no ImageNet . Possui a seguinte sintaxe -
keras.applications.resnet.ResNet50 (
include_top = True,
weights = 'imagenet',
input_tensor = None,
input_shape = None,
pooling = None,
classes = 1000
)
Aqui,
include_top refere-se à camada totalmente conectada no topo da rede.
weights consulte o pré-treinamento no ImageNet.
input_tensor refere-se ao tensor Keras opcional para usar como entrada de imagem para o modelo.
input_shaperefere-se à tupla de forma opcional. O tamanho de entrada padrão para este modelo é 224x224.
classes consulte o número opcional de classes para classificar as imagens.
Vamos entender o modelo escrevendo um exemplo simples -
Etapa 1: importar os módulos
Vamos carregar os módulos necessários conforme especificado abaixo -
>>> import PIL
>>> from keras.preprocessing.image import load_img
>>> from keras.preprocessing.image import img_to_array
>>> from keras.applications.imagenet_utils import decode_predictions
>>> import matplotlib.pyplot as plt
>>> import numpy as np
>>> from keras.applications.resnet50 import ResNet50
>>> from keras.applications import resnet50
Etapa 2: Selecione uma entrada
Deixe-nos escolher uma imagem de entrada, Lotus conforme especificado abaixo -
>>> filename = 'banana.jpg'
>>> ## load an image in PIL format
>>> original = load_img(filename, target_size = (224, 224))
>>> print('PIL image size',original.size)
PIL image size (224, 224)
>>> plt.imshow(original)
<matplotlib.image.AxesImage object at 0x1304756d8>
>>> plt.show()
Aqui, carregamos uma imagem (banana.jpg) e o exibiu.
Etapa 3: converter imagens em matriz NumPy
Vamos converter nossa entrada, Banana no array NumPy, para que possa ser passado para o modelo para fins de previsão.
>>> #convert the PIL image to a numpy array
>>> numpy_image = img_to_array(original)
>>> plt.imshow(np.uint8(numpy_image))
<matplotlib.image.AxesImage object at 0x130475ac8>
>>> print('numpy array size',numpy_image.shape)
numpy array size (224, 224, 3)
>>> # Convert the image / images into batch format
>>> image_batch = np.expand_dims(numpy_image, axis = 0)
>>> print('image batch size', image_batch.shape)
image batch size (1, 224, 224, 3)
>>>
Etapa 4: modelo de previsão
Vamos alimentar nossa entrada no modelo para obter as previsões
>>> prepare the image for the resnet50 model >>>
>>> processed_image = resnet50.preprocess_input(image_batch.copy())
>>> # create resnet model
>>>resnet_model = resnet50.ResNet50(weights = 'imagenet')
>>> Downloavding data from https://github.com/fchollet/deep-learning-models/releas
es/download/v0.2/resnet50_weights_tf_dim_ordering_tf_kernels.h5
102858752/102853048 [==============================] - 33s 0us/step
>>> # get the predicted probabilities for each class
>>> predictions = resnet_model.predict(processed_image)
>>> # convert the probabilities to class labels
>>> label = decode_predictions(predictions)
Downloading data from https://storage.googleapis.com/download.tensorflow.org/
data/imagenet_class_index.json
40960/35363 [==================================] - 0s 0us/step
>>> print(label)
Resultado
[
[
('n07753592', 'banana', 0.99229723),
('n03532672', 'hook', 0.0014551596),
('n03970156', 'plunger', 0.0010738898),
('n07753113', 'fig', 0.0009359837) ,
('n03109150', 'corkscrew', 0.00028538404)
]
]
Aqui, o modelo previu as imagens como banana corretamente.
Keras - modelos pré-treinados
Neste capítulo, aprenderemos sobre os modelos pré-treinados em Keras. Vamos começar com VGG16.
VGG16
VGG16é outro modelo pré-treinado. Ele também é treinado usando ImageNet. A sintaxe para carregar o modelo é a seguinte -
keras.applications.vgg16.VGG16(
include_top = True,
weights = 'imagenet',
input_tensor = None,
input_shape = None,
pooling = None,
classes = 1000
)
O tamanho de entrada padrão para este modelo é 224x224.
MobileNetV2
MobileNetV2é outro modelo pré-treinado. Também é treinado uingImageNet.
A sintaxe para carregar o modelo é a seguinte -
keras.applications.mobilenet_v2.MobileNetV2 (
input_shape = None,
alpha = 1.0,
include_top = True,
weights = 'imagenet',
input_tensor = None,
pooling = None,
classes = 1000
)
Aqui,
alphacontrola a largura da rede. Se o valor estiver abaixo de 1, diminui o número de filtros em cada camada. Se o valor estiver acima de 1, aumenta o número de filtros em cada camada. Se alfa = 1, o número padrão de filtros do papel é usado em cada camada.
O tamanho de entrada padrão para este modelo é 224x224.
InceptionResNetV2
InceptionResNetV2é outro modelo pré-treinado. Ele também é treinado usandoImageNet. A sintaxe para carregar o modelo é a seguinte -
keras.applications.inception_resnet_v2.InceptionResNetV2 (
include_top = True,
weights = 'imagenet',
input_tensor = None,
input_shape = None,
pooling = None,
classes = 1000)
Este modelo pode ser construído com o formato de dados 'channels_first' (canais, altura, largura) ou formato de dados 'channels_last' (altura, largura, canais).
O tamanho de entrada padrão para este modelo é 299x299.
InceptionV3
InceptionV3é outro modelo pré-treinado. Também é treinado uingImageNet. A sintaxe para carregar o modelo é a seguinte -
keras.applications.inception_v3.InceptionV3 (
include_top = True,
weights = 'imagenet',
input_tensor = None,
input_shape = None,
pooling = None,
classes = 1000
)
Aqui,
O tamanho de entrada padrão para este modelo é 299x299.
Conclusão
Keras é uma API de rede neural muito simples, extensível e fácil de implementar, que pode ser usada para construir aplicativos de aprendizagem profunda com abstração de alto nível. Keras é a escolha ideal para modelos de inclinação profunda.