A Inteligência Artificial (IA) ganhou uma quantidade significativa de popularidade nos últimos anos.
Se você é um engenheiro de software, cientista da computação ou entusiasta da ciência de dados em geral, provavelmente está intrigado com as incríveis aplicações de processamento de imagens, reconhecimento de padrões e detecção de objetos fornecidas por esse campo.
O subcampo mais importante da IA que você provavelmente já ouviu falar é o Deep Learning. Este campo se concentra em algoritmos poderosos (instruções de programas de computador) modelados após a funcionalidade do cérebro humano conhecida como Redes neurais.
Neste artigo, abordaremos o conceito de Redes Neurais e como construir, compilar, ajustar e avaliar esses modelos usando Python.
Redes neurais
Redes neurais, ou NNs, são uma série de algoritmos modelados após a atividade biológica do cérebro humano. As Redes Neurais consistem em nós, também chamados de neurônios.
Uma coleção de nós verticais é conhecida como camadas. O modelo consiste em uma entrada, uma saída e várias camadas ocultas. Cada camada é composta por nós, também chamados de neurônios, onde ocorrem os cálculos.
No diagrama a seguir, os círculos representam os nós e a coleção vertical de nós representa as camadas. Existem três camadas neste modelo.
Os nós de uma camada são conectados à próxima camada por meio de linhas de transmissão, como visto abaixo.
Nosso conjunto de dados consiste em dados rotulados. Isso significa que cada entidade de dados recebeu um determinado valor de nome.
Portanto, para um conjunto de dados de classificação de animais, teremos imagens de cães e gatos como nossos dados, com 'gato' e 'cachorro' como nossos rótulos.
É importante observar que os rótulos precisam ser convertidos em valores numéricos para que nosso modelo faça sentido, de modo que nossos rótulos de animais se tornem '0' para gato e '1' para cachorro. Tanto os dados quanto os rótulos são passados pelo modelo.
Aprendendo a
Os dados são alimentados ao modelo uma entidade por vez. Esses dados são divididos em pedaços e passados por cada nó do modelo. Os nós realizam operações matemáticas nesses pedaços.
Você não precisa conhecer as funções matemáticas ou cálculos para este tutorial, mas é importante ter uma ideia geral de como esses modelos funcionam. Após uma série de cálculos em uma camada, os dados são passados para a próxima camada e assim por diante.
Uma vez concluído, nosso modelo prevê o rótulo de dados na camada de saída (por exemplo, em um problema de classificação de animais, obtemos uma previsão '0' para um gato).
O modelo então compara esse valor previsto com o valor real do rótulo.
Se os valores corresponderem, nosso modelo receberá a próxima entrada, mas se os valores forem diferentes, o modelo calculará a diferença entre os dois valores, chamada perda, e ajustará os cálculos do nó para produzir rótulos correspondentes na próxima vez.
Estruturas de aprendizado profundo
Para construir redes neurais em código, precisamos importar Estruturas de aprendizado profundo conhecidas como bibliotecas usando nosso Ambiente de Desenvolvimento Integrado (IDE).
Esses frameworks são uma coleção de funções pré-escritas que nos ajudarão neste tutorial. Usaremos o framework Keras para construir nosso modelo.
Keras é uma biblioteca Python que usa um backend de aprendizado profundo e inteligência artificial chamado Tensorflow para criar NNs na forma de modelos sequenciais simples com facilidade.
Keras também vem com seus próprios modelos pré-existentes que também podem ser usados. Para este tutorial, estaremos criando nosso próprio modelo usando Keras.
Você pode aprender mais sobre essa estrutura de Deep Learning no Site Keras.
Construindo uma Rede Neural (Tutorial)
Vamos seguir para a construção de uma rede neural usando Python.
Problema Declaração
As Redes Neurais são um tipo de solução para problemas baseados em IA. Para este tutorial, examinaremos os dados de diabetes dos índios Pima, que estão disponíveis SUA PARTICIPAÇÃO FAZ A DIFERENÇA.
UCI Machine Learning compilou este conjunto de dados e contém um registro médico de pacientes indianos. Nosso modelo tem que prever se o paciente tem um início de diabetes dentro de 5 anos ou não.
Carregando conjunto de dados
Nosso conjunto de dados é um único arquivo CSV chamado 'diabetes.csv' que pode ser facilmente manipulado usando o Microsoft Excel.
Antes de criar nosso modelo, precisamos importar nosso conjunto de dados. Usando o seguinte código você pode fazer isso:
importar pandas como pd
dados = pd.read_csv('diabetes.csv')
x = data.drop(“Resultado”)
y = dados[“Resultado”]
Aqui estamos usando o Pandas biblioteca para poder manipular os dados do nosso arquivo CSV, read_csv() é uma função interna do Pandas que nos permite armazenar os valores em nosso arquivo em uma variável chamada 'data'.
A variável x contém nosso conjunto de dados sem os dados de resultado (rótulos). Conseguimos isso com a função data.drop() que remove os rótulos de x, enquanto y contém apenas os dados de resultado (rótulo).
Construindo Modelo Sequencial
Etapa 1: importando bibliotecas
Em primeiro lugar, precisamos importar o TensorFlow e o Keras, juntamente com alguns parâmetros necessários para o nosso modelo. O código a seguir nos permite fazer isso:
importar tensorflow como tf
de keras de importação tensorflow
de tensorflow.keras.models import Sequencial
de tensorflow.keras.layers import Ativação, Dense
de tensorflow.keras.optimizers import Adam
de tensorflow.keras.metrics import categorical_crossentropy
Para nosso modelo estamos importando camadas densas. Estas são camadas totalmente conectadas; isto é, cada nó em uma camada está totalmente conectado com outro nó na próxima camada.
Também estamos importando um ativação função necessária para dimensionar os dados enviados aos nós. Otimizadores também foram importados para minimizar a perda.
Adam é um otimizador de renome que torna nossos cálculos de nó de atualização de modelo com mais eficiência, juntamente com categórica_crossentropia que é o tipo de função de perda (calcula a diferença entre os valores de rótulo reais e previstos) que usaremos.
Etapa 2: projetando nosso modelo
O modelo que estou criando tem uma camada de entrada (com 16 unidades), uma oculta (com 32 unidades) e uma camada de saída (com 2 unidades). Esses números não são fixos e dependerão inteiramente do problema em questão.
Definir o número certo de unidades e camadas é um processo que pode ser aprimorado com a prática. A ativação corresponde ao tipo de dimensionamento que realizaremos em nossos dados antes de passá-los por um nó.
Relu e Softmax são funções de ativação reconhecidas para esta tarefa.
modelo = Sequencial([
Dense(unidades = 16, forma_entrada = (1,), ativação = 'relu'),
Denso(unidades = 32, ativação = 'relu'),
Denso(unidades = 2, ativação = 'softmax')
])
Veja como deve ser o resumo do modelo:
Treinando o modelo
Nosso modelo será treinado em duas etapas, sendo a primeira compilando o modelo (juntando o modelo) e a próxima ajustando o modelo em um determinado conjunto de dados.
Isso pode ser feito usando a função model.compile() seguida pela função model.fit().
model.compile(otimizador = Adam(learning_rate = 0.0001), perda = 'binary_crossentropy', métricas = ['precisão'])
model.fit(x, y, épocas = 30, batch_size = 10)
Especificar a métrica de 'precisão' nos permite observar a precisão do nosso modelo durante o treinamento.
Como nossos rótulos estão na forma de 1 e 0, usaremos uma função de perda binária para calcular a diferença entre os rótulos reais e previstos.
O conjunto de dados também está sendo dividido em lotes de 10 (batch_size) e será passado pelo modelo 30 vezes (épocas). Para um determinado conjunto de dados, x seriam os dados e y seriam os rótulos correspondentes aos dados.
Modelo de teste usando previsões
Para avaliar nosso modelo, fazemos previsões nos dados de teste usando a função predict().
previsões = model.predict(x)
E é isso!
Agora você deve ter uma boa compreensão do Aprendizagem profunda aplicativo, Redes Neurais, como eles funcionam em geral e como construir, treinar e testar um modelo em código Python.
Espero que este tutorial lhe dê o pontapé inicial para criar e implantar seus próprios modelos de Deep Learning.
Deixe-nos saber nos comentários se o artigo foi útil.
Deixe um comentário