Deep Learning with Python: Beginners Guide to Deep Learning



Este artigo fornecerá a você um conhecimento abrangente e detalhado do Deep Learning com Python e como ele é útil na vida do dia a dia.

é um dos tópicos mais quentes de 2018-19 e por um bom motivo. Houve tantos avanços na indústria em que chegou a hora em que as máquinas ou programas de computador estão realmente substituindo os humanos. este Aprendizado profundo com Python O artigo ajudará você a entender o que exatamente é Aprendizado Profundo e como essa transição foi possível. Abordarei os seguintes tópicos neste artigo:

Ciência de dados e seus componentes

Bem, Data Science é algo que existe há muito tempo. Ciência de dados é a extração de conhecimento de dados por meio de diferentes técnicas e algoritmos.





Linha do tempo AI - Aprendizado profundo com Python - Edureka

é uma técnica que permite que as máquinas imitem o comportamento humano. A ideia por trás da IA ​​é bastante simples, mas fascinante, que é fazer máquinas inteligentes que podem tomar decisões por conta própria. Por anos, pensou-se que os computadores nunca seriam compatíveis com a capacidade do cérebro humano.



Bem, naquela época não tínhamos dados e poder de computação suficientes, mas agora com Big Data surgindo e com o advento das GPUs, a Inteligência Artificial é possível.

como definir o caminho java no windows

é um subconjunto da técnica de IA que usa métodos estatísticos para permitir que as máquinas melhorem com a experiência.



Aprendizagem profunda é um subconjunto do ML que torna viável o cálculo da rede neural multicamada. Ele usa redes neurais para simular a tomada de decisão humana.

A necessidade de aprendizado profundo

Um passo em direção à inteligência artificial é o aprendizado de máquina. O aprendizado de máquina é um subconjunto da IA ​​e é baseado na ideia de que as máquinas devem ter acesso aos dados e devem ser deixadas para aprender e explorar por si mesmas. Ele lida com a extração de padrões de grandes conjuntos de dados. Lidar com grandes conjuntos de dados não era um problema.

  • Algoritmos de aprendizado de máquina não pode lidar com dados de dimensões elevadas - onde temos um grande número de entradas e saídas: arredondar milhares de dimensões. O manuseio e o processamento desse tipo de dados se tornam muito complexos e esgotam os recursos. Isso é denominado como Maldição da Dimensionalidade.

  • Outro desafio enfrentado foi, para especificar o recursos a serem extraídos . Isso desempenha um papel importante na previsão do resultado, bem como na obtenção de uma melhor precisão. Portanto, sem extração de recursos, o desafio para o programador aumenta à medida que a eficácia do algoritmo depende muito de quão perspicaz é o programador.

Agora, é aqui que o Deep Learning veio ao resgate. Aprendizagem profunda é capaz de lidar com os dados dimensionais elevados e também é eficiente em focando nos recursos certos sozinho.

O que é Deep Learning?

Aprendizado profundo é um subconjunto do aprendizado de máquina em que algoritmos de aprendizado de máquina semelhantes são usados ​​para treinar de modo a obter uma melhor precisão nos casos em que o primeiro não estava indo à altura da marca. Basicamente, O aprendizado profundo imita a maneira como nosso cérebro funciona ou seja, aprende com a experiência.

Como você sabe,nosso cérebro é feito de bilhões de neurônios que nos permite fazer coisas incríveis. Mesmo o cérebro de uma criança pequena é capaz de resolver problemas complexos que são muito difíceis de resolver, mesmo usando supercomputadores. Então, como podemos alcançar a mesma funcionalidade em um programa? Agora, é aqui que entendemos Neurônio Artificial (Perceptron) e Rede neural artificial.

Perceptron e redes neurais artificiais

O Deep Learning estuda a unidade básica de um cérebro chamada célula cerebral ou neurônio. Agora, vamos entender a funcionalidade dos neurônios biológicos e como imitamos essa funcionalidade na percepção de um neurônio artificial.

  • Dendrito: Recebe sinais de outros neurônios
  • Corpo celular: Soma todas as entradas
  • Axônio: É usado para transmitir sinais para as outras células

Um neurônio artificial ou um Perceptron é um modelo linear usado para classificação binária. Ele modela um neurônio que possui um conjunto de entradas, cada uma com um peso específico. O neurônio calcula alguma função nestes pesada entradas e dá a saída.

Ele recebe n entradas (correspondentes a cada recurso). Em seguida, soma essas entradas, aplica uma transformação e produz uma saída. Tem duas funções:

  • Soma
  • Transformação (Ativação)

O peso mostra a eficácia de uma determinada entrada. Mais o peso da entrada, mais terá um impacto na rede neural . Por outro lado, Viés é um parâmetro adicional no Perceptron, que é usado para ajustar a saída junto com a soma ponderada das entradas para o neurônio, o que ajuda o modelo de uma forma que pode se ajustar melhor aos dados fornecidos.

Funções de ativação traduz as entradas em saídas. Ele usa um limite para produzir uma saída. Existem muitas funções que são usadas como funções de ativação, como:

  • Linear ou Identidade
  • Unidade ou etapa binária
  • Sigmóide ou logística
  • Tanh
  • ReLU
  • Softmax

Bem. se você acha que o Perceptron resolve o problema, você está errado. Houve dois problemas principais:

  • Perceptrons de camada única não pode classificar pontos de dados separáveis ​​não linearmente .
  • Problemas complexos, que envolvem muitos parâmetros não pode ser resolvido por Perceptrons de Camada Única.

Considere o exemplo aqui e a complexidade com os parâmetros envolvidos para tomar uma decisão pela equipe de marketing.

Um neurônio não pode receber tantas entradas e é por isso que mais de um neurônio seria usado para resolver este problema. Rede Neural é realmente apenas um composição de Perceptrons, conectados de maneiras diferentes e operando em diferentes funções de ativação.

  • Nós de entrada fornecem informações do mundo externo para a rede e são chamados de “Camada de entrada”.
  • Nós Escondidos realizar cálculos e transferir informações dos nós de entrada para os nós de saída. Uma coleção de nós ocultos forma uma “Camada Oculta”.
  • Nós de saída são chamados coletivamente de “Camada de Saída” e são responsáveis ​​por cálculos e transferência de informações da rede para o mundo externo.

Agora que você tem uma ideia de como um perceptron se comporta, os diferentes parâmetros envolvidos e as diferentes camadas de uma rede neural, vamos continuar este Deep Learning com Python Blog e ver alguns aplicativos interessantes de Deep Learning.

Aplicações de Aprendizado Profundo

Existem várias aplicações de Deep Learning na indústria, aqui estão algumas das mais importantes que estão presentes em nossas tarefas do dia a dia.

  • Reconhecimento de fala

  • Maquina de tradução

  • Reconhecimento facial e marcação automática

  • Assistentes pessoais virtuais

  • Auto-condução automóvel

  • Chatbots

Por que Python para aprendizado profundo?

  • é uma dessas ferramentas que tem um atributo único, de ser um linguagem de programação de propósito geral como sendo fácil de usar quando se trata de computação analítica e quantitativa.
  • É muito fácil de entender
  • Python é Digitado dinamicamente
  • Enorme
  • Uma vasta gama de bibliotecas para diferentes fins, como Numpy, Seaborn, Matplotlib, Pandas e Scikit-aprenda

Agora chega de teoria, vamos ver como podemos iniciar o Deep Learning com Python com um pequeno, mas emocionante exemplo.

Aprendizado profundo com Python: exemplo de Perceptron

Agora tenho certeza de que vocês devem estar familiarizados com o funcionamento do OU' Portão. A saída é 1 se alguma das entradas também for 1.

Portanto, um Perceptron pode ser usado como um separador ou uma linha de decisão que divide o conjunto de entrada da porta OR em duas classes:

Classe 1: Entradas com saída como 0 que fica abaixo da linha de decisão.
Classe 2: Entradas com saída como 1 que fica acima da linha de decisão ou separador.

como usar o tableau public

Até agora, entendemos que um perceptron linear pode ser usado para classificar o conjunto de dados de entrada em duas classes. Mas, como ele realmente classifica os dados?

Matematicamente, um perceptron pode ser pensado como uma equação de pesos, entradas e polarização.

Etapa 1: importar toda a biblioteca necessária

Aqui, vou importar apenas uma biblioteca, ou seja, TensorFlow

importar tensorflow como tf

Etapa 2: Definir variáveis ​​vetoriais para entrada e saída

Em seguida, precisamos criar variáveis ​​para armazenar a entrada, a saída e o viés do Perceptron.

train_in = [[0,0,1], [0,1,1], [1,0,1], [1,1,1]] train_out = [[0], [1], [1], [1]]

Etapa 3: definir a variável de peso

Aqui vamos definir a variável tensorial de forma 3 × 1 para nossos pesos e atribuir alguns valores aleatórios a ela inicialmente.

w = tf.Variable (tf.random_normal ([3, 1], seed = 15))

Etapa 4: Definir marcadores de posição para entrada e saída

Precisamos definir marcadores de posição para que possam aceitar entradas externas durante a execução.

x = tf.placeholder (tf.float32, [Nenhum, 3]) y = tf.placeholder (tf.float32, [Nenhum, 1])

Etapa 5: calcular a saída e a função de ativação

Conforme discutido anteriormente, a entrada recebida por um perceptron é primeiro multiplicada pelos respectivos pesos e, em seguida, todas essas entradas ponderadas são somadas. Este valor somado é então alimentado para ativação para obtenção do resultado final.

output = tf.nn.relu (tf.matmul (x, w))

Nota: neste caso, usei relu como minha função de ativação. Você é livre para usar qualquer uma das funções de ativação de acordo com sua necessidade.

Etapa 6: calcule o custo ou erro

Precisamos calcular o custo = erro quadrático médio, que nada mais é do que o quadrado da diferença entre a saída do perceptron e a saída desejada.

perda = tf.reduce_sum (tf.square (output - y))

Etapa 7: Minimize o erro

O objetivo de um perceptron é minimizar a perda ou custo ou erro. Então, vamos usar o Gradient Descent Optimizer.

optimizer = tf.train.GradientDescentOptimizer (0,01) train = optimizer.minimize (loss)

Etapa 8: inicializar todas as variáveis

Variáveis ​​são definidas apenas com tf.Variable. Portanto, precisamos inicializar as variáveis ​​definidas.

init = tf.global_variables_initializer () sess = tf.Session () sess.run (init)

Etapa 9: Treinamento do Perceptron em Iterações

Precisamos treinar nosso perceptron, ou seja, atualizar os valores dos pesos e do viés na iteração sucessiva para minimizar o erro ou perda. Aqui, treinarei nosso perceptron em 100 épocas.

para i no intervalo (100): sess.run (train, {x: train_in, y: train_out}) cost = sess.run (perda, feed_dict = {x: train_in, y: train_out}) print ('Epoch-- ', i,' - perda - ', custo)

Etapa 10: Saída

……

……

Como você pode ver aqui, a perda começou em 2.07 e terminou em 0,27

.

Aprendizado profundo com Python: criando uma rede neural profunda

Agora que criamos com sucesso um perceptron e o treinamos para uma porta OR. Vamos continuar este artigo e ver como podemos criar nossa própria rede neural a partir do zero, onde criaremos uma camada de entrada, camadas ocultas e camada de saída.

Vamos usar o conjunto de dados MNIST. O conjunto de dados MNIST consiste em 60.000 treinamento amostras e 10.000 testes amostras de imagens de dígitos manuscritas. As imagens são de tamanho 28 × 28 pixels e a saída pode estar entre 0-9 .

A tarefa aqui é treinar um modelo que possa identificar com precisão o dígito presente na imagem

Primeiramente, vamos usar a importação abaixo para trazer a função de impressão do Python 3 para o Python 2.6+. instruções __future__ precisam estar perto do início do arquivo porque mudam coisas fundamentais sobre a linguagem e, portanto, o compilador precisa saber sobre elas desde o início

from __future__ import print_function

A seguir está o código com comentários em cada etapa

# Importar dados MNIST de tensorflow.examples.tutorials.mnist import input_data mnist = input_data.read_data_sets ('/ tmp / data /', one_hot = True) importar tensorflow como tf import matplotlib.pyplot as plt # Parameters learning_rate = 0,001 training_epochs = 15 batch_size = 100 display_step = 1 # Parâmetros de rede n_hidden_1 = 256 # Número da 1ª camada de recursos n_hidden_2 = 256 # Número da 2ª camada de recursos n_input = 784 # Entrada de dados MNIST (formato de img: 28 * 28) n_classes = 10 # MNIST classes totais ( 0-9 dígitos) # tf Graph input x = tf.placeholder ('float', [None, n_input]) y = tf.placeholder ('float', [None, n_classes]) # Criar modelo def multilayer_perceptron (x, pesos , vieses): # Camada oculta com ativação de RELU layer_1 = tf.add (tf.matmul (x, pesos ['h1']), biases ['b1']) layer_1 = tf.nn.relu (layer_1) # Camada oculta com ativação de RELU camada_2 = tf.add (tf.matmul (camada_1, pesos ['h2']), vieses ['b2']) camada_2 = tf.nn.relu (camada_2) # Camada de saída com ativação linear out_layer = tf. matmul (camada _2, pesos ['out']) + biases ['out'] return out_layer # Armazena o peso e os pesos das camadas = {'h1': tf.Variable (tf.random_normal ([n_input, n_hidden_1])), 'h2' : tf.Variable (tf.random_normal ([n_hidden_1, n_hidden_2])), 'out': tf.Variable (tf.random_normal ([n_hidden_2, n_classes]))} biases = {'b1': tf.Variable (tf. random_normal ([n_hidden_1])), 'b2': tf.Variable (tf.random_normal ([n_hidden_2])), 'out': tf.Variable (tf.random_normal ([n_classes]))} # Construct model pred = multilayer_perceptron (x, pesos, vieses) # Definir perda e custo do otimizador = tf.reduce_mean (tf.nn.softmax_cross_entropy_with_logits (logits = pred, labels = y)) optimizer = tf.train.AdamOptimizer (learning_rate = learning_rate) .minimize (cost) # Inicializando as variáveis ​​init = tf.global_variables_initializer () #create uma lista vazia para armazenar o histórico de custos e precisão cost_history = [] precision_history = [] # Inicie o gráfico com tf.Session () as sess: sess.run (init ) # Ciclo de treinamento para época no intervalo (training_epochs): avg_cost = 0. total_batch = int (mnist.train.num_examples / batch_size) # Loop em todos os lotes para i no intervalo (total_batch): batch_x, batch_y = mnist.train.next_batch (batch_size) # Executar otimização op (backprop) e custo op (para obter o valor de perda) _, c = sess.run ([otimizador, custo], feed_dict = {x: batch_x, y: batch_y}) # Calcular perda média avg_cost + = c / total_batch # Exibir logs por etapa de época se epoch% display_step == 0: correct_prediction = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Calcular precisão precisão = tf.reduce_mean (tf.cast (correct_prediction, 'float') ) acu_temp = exatidão.eval ({x: mnist.test.images, y: mnist.test.labels}) # anexar a exatidão à lista exatidão_history.append (acu_temp) # anexar o histórico de custos cost_history.append (avg_cost) imprimir ('Epoch:', '% 04d'% (epoch + 1), '- cost =', '{: .9f}'. Format (avg_cost), '- Accuracy =', acu_temp) print ('Otimização concluída! ') #plot the cost history plt.plot (cost_history) plt.show () #plot the cost history plt.plot (exatidão _history) plt.show () # Modelo de teste correct_prediction = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Calcular precisão precisão = tf.reduce_mean (tf.cast (correct_prediction, ' float ')) print (' Precisão: ', precisão.eval ({x: mnist.test.images, y: mnist.test.labels}))

Resultado:

java criar matriz de objetos

Agora, com isso, chegamos ao final deste artigo de Aprendizado profundo com Python. Espero que você tenha entendido os vários componentes do Deep Learning, como tudo começou e como, usando Python, podemos criar um perceptron simples e uma rede neural profunda.

Edureka's é curado por profissionais da indústria de acordo com os requisitos e demandas da indústria. Você vai dominar conceitos como função SoftMax, Redes Neurais Autoencoder, Máquina Boltzmann Restrita (RBM) e trabalhar com bibliotecas como Keras & TFLearn. O curso foi especialmente curado por especialistas do setor com estudos de caso em tempo real.

Tem alguma questão para nós? Mencione isso na seção de comentários de “Aprendizado profundo com Python” e entraremos em contato com você.