Este artigo foi publicado como parte do Data Science Blogathon
Neste artigo, vamos responder a essas perguntas básicas e construir uma rede neural básica para realizar a regressão linear.
O que é uma rede neural?
A unidade básica do cérebro é conhecida como neurônio, existem aproximadamente 86 bilhões de neurônios em nosso sistema nervoso que estão conectados a 10 ^ 14-10 ^ 15 sinapse. mimCada neurônio recebe um sinal das sinapses e o envia após o processamento do sinal.. Esta ideia é extraída do cérebro para construir uma rede neural.
Cada neurônio realiza um produto escalar entre as entradas e os pesos, adicionar preconceitos, aplica uma função de gatilho e produz as saídas. Quando um grande número de neurônios estão presentes juntos para dar um grande número de resultados, uma camada neural é formada. Finalmente, várias camadas se combinam para formar uma rede neural.
Arquitectura de red neuronal
As redes neurais são formadas quando várias camadas neurais se combinam para fornecer uma rede, ou podemos dizer que existem algumas camadas cujas saídas são entradas para outras camadas.
O tipo mais comum de camada para construir uma rede neural básica é o camada totalmente conectada, em que as camadas adjacentes estão completamente emparelhadas e os neurônios de camada única não estão conectados uns aos outros.
Na figura acima, redes neurais são usadas para classificar pontos de dados em três categorias.
Convenções de nomenclatura. Quando a rede neural N-layer, não contamos a camada de entrada. Portanto, uma rede neural de camada única descreve uma rede sem camadas ocultas (a entrada é mapeada diretamente para a saída). No caso do nosso código, vamos usar uma rede neural de camada única, quer dizer, não temos uma camada escondida.
Camada de saída. Ao contrário de todas as camadas de uma rede neural, neurônios na camada de saída geralmente não têm uma função de disparo (ou você pode pensar que eles têm uma função de ativação de identidade linear). Isso ocorre porque a última camada de saída geralmente é usada para representar as pontuações da classe (por exemplo, na classificação), que são números de valor real arbitrário ou algum tipo de alvo de valor real (por exemplo, em regressão). Como estamos fazendo a regressão usando uma única camada, não temos nenhuma função de ativação.
Dimensionamento da rede neural. As duas métricas que as pessoas normalmente usam para medir o tamanho das redes neurais são o número de neurônios ou, mais comumente, o número de parâmetros.
Bibliotecas
Usaremos três bibliotecas básicas para este modelo, entorpecido, matplotlib e TensorFlow.
- Numpy: isso adiciona suporte para matrizes e matrizes grandes e multidimensionais, junto com uma grande coleção de funções matemáticas de alto nível. No nosso caso, vamos gerar dados com a ajuda do Numpy.
- Matplotlib: esta é uma biblioteca de plotagem para python, vamos visualizar os resultados finais usando gráficos em Matplotlib.
- Tensorflow: esta biblioteca tem um foco particular no treinamento de rede neural profunda e inferência. Podemos importar diretamente as camadas e treinar, testar funções sem ter que escrever todo o programa.
importar numpy como np import matplotlib.pyplot as plt importar tensorflow como tf
Gerando dados
Podemos gerar nossos próprios dados numéricos para este processo usando a função np.unifrom () que gera dados uniformes. Aqui, estamos usando duas variáveis de entrada xs e zs, adicionar algum ruído para randomizar os pontos de dados e, Finalmente, a variável de destino é definida como y = 2 * xs-3 * zs + 5 + barulho. O tamanho do conjunto de dados é 1000.
observações = 1000 xs = np.random.uniform(-10,10,(observações,1)) zs = np.random.uniform(-10,10,(observações,1)) geradas_inputs = np.column_stack((xs,zs)) noise = np.random.uniform(-10,10,(observações,1)) alvo_gerado = 2 * xs-3 * zs + 5 + ruído
Depois de gerar os dados, salve-os em um arquivo .npz, para que possam ser usados para treinamento.
np. saber('TF_intro',input = generated_inputs,alvos = alvo_gerado)
training_data = np.load('TF_intro.npz')
Nosso objetivo é obter os pesos finais o mais próximo possível dos pesos reais., quer dizer [2,-3].
Definindo o modelo
Aqui, usaremos a camada densa do TensorFlow para fazer o modelo e importar a descida do gradiente estocástico do otimizador Keras.
Um gradiente é a inclinação de uma função. Mede o grau em que uma variável muda com as mudanças em outra variável. Matematicamente, gradiente descendente é uma função convexa cuja saída é a derivação parcial de um conjunto de parâmetros de suas entradas. Quanto maior a inclinação, quanto mais íngreme a encosta.
Começando com um valor inicial, Gradient Descent é executado iterativamente para encontrar os valores ideais dos parâmetros para encontrar o valor mínimo possível para a função de custo dada. Palavra “estocástico” refere-se a um sistema ou processo de probabilidade aleatória. Portanto, en Stochastic Gradient Descent, algumas amostras são selecionadas aleatoriamente, em vez do conjunto de dados para cada iteração.
Dado que, a entrada tem 2 variáveis, tamanho da entrada = 2 e tamanho de saída = 1.
Definimos a taxa de aprendizagem em 0.02, que não é nem muito alto nem muito baixo, e o valor de época = 100.
input_size = 2
output_size = 1
models = tf.keras.Sequential([
tf.hard.layers.Dense(output_size)
])
custom_optimizer = tf.keras.optimizers.SGD(learning_rate = 0,02)
models.compile(optimizer = custom_optimizer,perda ="mean_squared_error")
models.fit(training_data['entrada'],training_data['alvos'],épocas = 100, verboso = 1)
Obtenha pesos e preconceitos
Podemos imprimir os valores previstos de pesos e vieses e também armazená-los.
models.layers[0].get_weights()
[variedade([[ 1.3665189],
[-3.1609795]], dtype = float32), variedade([4.9344487], dtype = float32)]
Aqui, a primeira matriz representa os pesos e a segunda matriz representa os vieses. Podemos ver claramente que os valores previstos dos pesos estão muito próximos do valor real dos pesos..
pesos = modelos.camadas[0].get_weights()[0] bias = models.layers[0].get_weights()[1]
Predição e precisão
Após a previsão usando os pesos e vieses dados, uma pontuação RMSE final de 0.02866, que é bastante baixo.
RMSE é definido como a raiz quadrada média do erro. A raiz quadrada média do erro leva a diferença para cada valor observado e previsto. A fórmula para o erro RMSE é dada como:
https://www.google.com/search?q = rmse + fórmula&oq = RMSE + forma&aqs = cromo.0.0i433j0j69i57j0l7.4779j0j7&sourceid = chrome&ie = UTF-8
 |
|
|
|
 |
|
|
|
 |
|
|
|
 |
|
|
out = training_data['alvos'].volta(1) de sklearn.metrics import mean_squared_error mean_squared_error(gerada_destino, Fora, quadrado = falso)
Se plotarmos os dados previstos em um gráfico de dispersão, nós temos um gráfico como este:
plt.scatter(np.squeeze(models.predict_on_batch(training_data['entrada'])),np.squeeze(training_data['alvos']),c ="#88c999")
plt.xlabel('Entrada')
plt.ylabel('Produção Prevista')
plt.show()
Viva! Nosso modelo é treinado corretamente com poucos erros. Este é o fim da sua primeira rede neural. Observe que cada vez que treinamos o modelo, podemos obter um valor de precisão diferente, mas eles não diferem muito.
Obrigado pela leitura! Você pode entrar em contato comigo em [e-mail protegido]
A mídia mostrada neste artigo não é propriedade da DataPeaker e é usada a critério do autor.
