Aprendizaje profundo con Python: Guía para principiantes de aprendizaje profundo

es uno de los temas más candentes de 2018-19 y por una buena razón. Ha habido tantos avances en la industria en los que ha llegado el momento en que las máquinas o los programas de computadora están reemplazando a los humanos. Esta Aprendizaje profundo con Python Este artículo lo ayudará a comprender qué es exactamente el aprendizaje profundo y cómo se ha hecho posible esta transición. Cubriré los siguientes temas en este artículo:

• Ciencia de datos y sus componentes
• La necesidad del aprendizaje profundo
• ¿Qué es el aprendizaje profundo?
• Perceptrón y redes neuronales artificiales
• Aplicaciones del aprendizaje profundo
• ¿Por qué Python para el aprendizaje profundo?
• Aprendizaje profundo con Python: ejemplo de Perceptron
• Aprendizaje profundo con Python: creación de una red neuronal profunda

Ciencia de datos y sus componentes

Bueno, la ciencia de datos es algo que ha estado ahí durante años. Ciencia de los datos es la extracción de conocimiento a partir de datos mediante el uso de diferentes técnicas y algoritmos.

es una técnica que permite a las máquinas imitar el comportamiento humano. La idea detrás de la IA es bastante simple pero fascinante, que consiste en crear máquinas inteligentes que puedan tomar decisiones por sí mismas. Durante años, se pensó que las computadoras nunca igualarían el poder del cerebro humano.

Bueno, en ese entonces no teníamos suficientes datos y capacidad de cálculo, pero ahora con Big Data surgiendo y con la llegada de las GPU, la Inteligencia Artificial es posible.

es un subconjunto de la técnica de IA que utiliza métodos estadísticos para permitir que las máquinas mejoren con la experiencia.

Aprendizaje profundo es un subconjunto de ML que hace factible el cálculo de redes neuronales multicapa. Utiliza redes neuronales para simular la toma de decisiones similar a la humana.

La necesidad del aprendizaje profundo

Un paso hacia la inteligencia artificial es el aprendizaje automático. El aprendizaje automático es un subconjunto de la inteligencia artificial y se basa en la idea de que las máquinas deben tener acceso a los datos y deben dejar que aprendan y exploren por sí mismas. Se ocupa de la extracción de patrones de grandes conjuntos de datos. El manejo de grandes conjuntos de datos no fue un problema.

• Algoritmos de aprendizaje automático no puede manejar datos de alta dimensión - donde tenemos una gran cantidad de entradas y salidas: alrededor de miles de dimensiones. El manejo y procesamiento de este tipo de datos se vuelve muy complejo y agotador de recursos. Esto se denomina Maldición de dimensionalidad.

• Otro desafío enfrentado fue, especificar el características a extraer . Esto juega un papel importante en la predicción del resultado y en el logro de una mayor precisión. Por lo tanto, sin extracción de características, el desafío para el programador aumenta a medida que la efectividad del algoritmo depende en gran medida de lo perspicaz que sea el programador.

Ahora, aquí es donde Deep Learning vino al rescate. El aprendizaje profundo es capaz de manejar los datos de alta dimensión y también es eficiente en centrarse en las funciones adecuadas por sí mismo.

¿Qué es el aprendizaje profundo?

El aprendizaje profundo es un subconjunto del aprendizaje automático en el que se utilizan algoritmos de aprendizaje automático similares para entrenar a fin de lograr una mayor precisión en los casos en que el primero no se desempeñaba a la perfección. Básicamente, El aprendizaje profundo imita la forma en que funciona nuestro cerebro es decir, aprende de la experiencia.

Como usted sabe,nuestro cerebro se compone de miles de millones de neuronas que nos permite hacer cosas increíbles. Incluso el cerebro de un niño pequeño es capaz de resolver problemas complejos que son muy difíciles de resolver incluso utilizando supercomputadoras. Entonces, ¿cómo podemos lograr la misma funcionalidad en un programa? Ahora, aquí es donde entendemos Neurona artificial (perceptrón) y Red neuronal artificial.

Perceptrón y redes neuronales artificiales

El aprendizaje profundo estudia la unidad básica de un cerebro llamada célula cerebral o neurona. Ahora, entendamos la funcionalidad de las neuronas biológicas y cómo imitamos esta funcionalidad en la percepción de una neurona artificial.

• Dendrita: Recibe señales de otras neuronas
• Cuerpo de la célula: Suma todas las entradas
• Axón: Se utiliza para transmitir señales a las otras células.

Una neurona artificial o una Perceptrón es un modelo lineal utilizado para la clasificación binaria. Modela una neurona que tiene un conjunto de entradas, a cada una de las cuales se le asigna un peso específico. La neurona calcula alguna función en estos ponderado entradas y da la salida.

valor predeterminado de cadena en java

Recibe n entradas (correspondientes a cada característica). Luego suma esas entradas, aplica una transformación y produce una salida. Tiene dos funciones:

• Suma
• Transformación (activación)

El peso muestra la efectividad de una entrada en particular. Cuanto mayor sea el peso de la entrada, más tendrá un impacto en la red neuronal . Por otra parte, Parcialidad es un parámetro adicional en el Perceptron, que se utiliza para ajustar la salida junto con la suma ponderada de las entradas a la neurona, lo que ayuda al modelo de una manera que se ajusta mejor a los datos dados.

Funciones de activación traduce las entradas en salidas. Utiliza un umbral para producir una salida. Hay muchas funciones que se utilizan como funciones de activación, como:

• Lineal o Identidad
• Paso unitario o binario
• Sigmoide o Logística
• Tanh
• ReLU
• Softmax

Bien. si cree que Perceptron resuelve el problema, está equivocado. Hubo dos problemas importantes:

• Perceptrones de una sola capa no puede clasificar puntos de datos separables de forma no lineal .
• Problemas complejos, que involucran muchos parámetros no puede ser resuelto por perceptrones de capa única.

Considere el ejemplo aquí y la complejidad de los parámetros involucrados para tomar una decisión por parte del equipo de marketing.

Una neurona no puede absorber tantas entradas y es por eso que se usaría más de una neurona para resolver este problema. Neural Network es realmente solo una composición de perceptrones, conectados de diferentes maneras y operando en diferentes funciones de activación.

• Nodos de entrada proporcionan información del mundo exterior a la red y, en conjunto, se denominan 'Capa de entrada'.
• Nodos ocultos realizar cálculos y transferir información desde los nodos de entrada a los nodos de salida. Una colección de nodos ocultos forma una 'capa oculta'.
• Nodos de salida se denominan colectivamente la 'capa de salida' y son responsables de los cálculos y la transferencia de información desde la red al mundo exterior.

Ahora que tiene una idea de cómo se comporta un perceptrón, los diferentes parámetros involucrados y las diferentes capas de una red neuronal, continuemos con este blog de aprendizaje profundo con Python y veamos algunas aplicaciones interesantes de aprendizaje profundo.

Aplicaciones del aprendizaje profundo

Existen varias aplicaciones de Deep Learning en la Industria, aquí están algunas de las importantes que están presentes en nuestras tareas del Día a Día.

• Reconocimiento de voz

• Máquina traductora

• Reconocimiento facial y etiquetado automático

• Asistentes personales virtuales

• Coche de conducción autónoma

• Chatbots

¿Por qué Python para el aprendizaje profundo?

• es una de esas herramientas que tiene un atributo único, de ser un lenguaje de programación de propósito general como siendo fácil de usar cuando se trata de computación analítica y cuantitativa.
• Es muy fácil de comprender
• Python es Escrito dinámicamente
• Enorme
• Una amplia gama de bibliotecas para diferentes propósitos como Numpy, Seaborn, Matplotlib, Pandas y Scikit-learn

Ahora basta de teoría. Veamos cómo podemos iniciar el aprendizaje profundo con Python con un ejemplo pequeño pero emocionante.

Aprendizaje profundo con Python: ejemplo de Perceptron

Ahora estoy seguro de que ustedes deben estar familiarizados con el funcionamiento del ' O' portón. La salida es 1 si alguna de las entradas también es 1.

tipos de transformación en informática

Por lo tanto, un perceptrón se puede utilizar como un separador o una línea de decisión que divide el conjunto de entrada de la puerta OR, en dos clases:

Clase 1: Entradas que tienen una salida como 0 que se encuentra por debajo de la línea de decisión.
Clase 2: Entradas que tienen la salida como 1 que se encuentra por encima de la línea de decisión o el separador.

Hasta ahora, entendíamos que se puede usar un perceptrón lineal para clasificar el conjunto de datos de entrada en dos clases. Pero, ¿cómo clasifica realmente los datos?

Matemáticamente, un perceptrón puede considerarse como una ecuación de pesos, entradas y sesgos.

Paso 1: importar toda la biblioteca requerida

Aquí voy a importar solo una biblioteca, es decir. TensorFlow

importar tensorflow como tf

Paso 2: definir variables vectoriales para entrada y salida

A continuación, necesitamos crear variables para almacenar la entrada, la salida y el sesgo del Perceptron.

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

Paso 3: definir la variable de peso

Aquí definiremos la variable tensorial de forma 3 × 1 para nuestros pesos y le asignaremos algunos valores aleatorios inicialmente.

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

Paso 4: definir marcadores de posición para entrada y salida

Necesitamos definir marcadores de posición para que puedan aceptar entradas externas sobre la marcha.

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

Paso 5: Calcular la salida y la función de activación

Como se discutió anteriormente, la entrada recibida por un perceptrón primero se multiplica por los respectivos pesos y luego, todas estas entradas ponderadas se suman. Este valor sumado se alimenta luego a la activación para obtener el resultado final.

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

Nota: En este caso, he utilizado relu como mi función de activación. Puede utilizar cualquiera de las funciones de activación según sus necesidades.

Paso 6: Calcule el costo o el error

Necesitamos calcular el costo = error cuadrático medio, que no es más que el cuadrado de la diferencia entre la salida del perceptrón y la salida deseada.

pérdida = tf.reduce_sum (tf.square (salida - y))

Paso 7: minimizar el error

El objetivo de un perceptrón es minimizar la pérdida, el costo o el error. Así que aquí vamos a utilizar el Optimizador de descenso de gradientes.

optimizer = tf.train.GradientDescentOptimizer (0.01) train = optimizer.minimize (pérdida)

Paso 8: inicializar todas las variables

Las variables solo se definen con tf.Variable. Entonces, necesitamos inicializar las variables definidas.

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

Paso 9: entrenamiento del perceptrón en iteraciones

Necesitamos entrenar nuestro perceptrón, es decir, actualizar los valores de los pesos y el sesgo en la iteración sucesiva para minimizar el error o la pérdida. Aquí, entrenaré a nuestro perceptrón en 100 épocas.

para i en el rango (100): sess.run (tren, {x: train_in, y: train_out}) cost = sess.run (loss, feed_dict = {x: train_in, y: train_out}) print ('Época-- ', i,' - pérdida - ', costo)

Paso 10: Salida

……

……

mutable e inmutable en java

Como puede ver aquí, la pérdida comenzó en 2.07 y terminó en 0.27

.

Aprendizaje profundo con Python: creación de una red neuronal profunda

Ahora que hemos creado con éxito un perceptrón y lo hemos entrenado para una puerta OR. Continuemos con este artículo y veamos cómo podemos crear nuestra propia red neuronal desde cero, donde crearemos una capa de entrada, capas ocultas y capa de salida.

Vamos a utilizar el conjunto de datos MNIST. El conjunto de datos MNIST consta de 60.000 formación muestras y 10,000 pruebas muestras de imágenes de dígitos manuscritas. Las imagenes son de tamaño 28 × 28 píxeles y la salida puede estar entre 0-9 .

La tarea aquí es entrenar un modelo que pueda identificar con precisión el dígito presente en la imagen

En primer lugar, usaremos la siguiente importación para llevar la función de impresión de Python 3 a Python 2.6+. Las declaraciones __future__ deben estar cerca de la parte superior del archivo porque cambian cosas fundamentales sobre el lenguaje, por lo que el compilador debe conocerlas desde el principio.

de __future__ import print_function

A continuación se muestra el código con comentarios en cada paso.

# Importar datos MNIST de tensorflow.examples.tutorials.mnist import input_data mnist = input_data.read_data_sets ('/ tmp / data /', one_hot = True) import tensorflow as tf import matplotlib.pyplot as plt # Parámetros learning_rate = 0.001 training_epochs = 15 batch_size = 100 display_step = 1 # Network Parameters n_hidden_1 = 256 # 1st layer number of features n_hidden_2 = 256 # 2nd layer number of features n_input = 784 # MNIST data input (img shape: 28 * 28) n_classes = 10 # MNIST total classes ( 0-9 dígitos) # tf Entrada de gráfico x = tf.placeholder ('float', [None, n_input]) y = tf.placeholder ('float', [None, n_classes]) # Crear modelo def multilayer_perceptron (x, weights , sesgos): # Capa oculta con activación RELU layer_1 = tf.add (tf.matmul (x, weights ['h1']), bias ['b1']) layer_1 = tf.nn.relu (layer_1) # Capa oculta con activación RELU layer_2 = tf.add (tf.matmul (layer_1, pesos ['h2']), sesgos ['b2']) layer_2 = tf.nn.relu (layer_2) # Capa de salida con activación lineal out_layer = tf. matmul (capa _2, ponderaciones ['out']) + sesgos ['out'] return out_layer # Almacenar capas peso y sesgo ponderaciones = {'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]))} sesgos = {'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]))} # Construir modelo pred = multilayer_perceptron (x, pesos, sesgos) # Definir pérdida y optimizador costo = 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 las variables init = tf.global_variables_initializer () #crear una lista vacía para almacenar el historial de costos y el historial de precisión cost_history = [] precision_history = [] # Lanzar el gráfico con tf.Session () como sess: sess.run (init ) # Ciclo de entrenamiento para epoch en rango (training_epochs): avg_cost = 0. total_batch = int (mnist.train.num_examples / batch_size) # Recorre todos los lotes para i en el rango (total_batch): batch_x, batch_y = mnist.train.next_batch (batch_size) # Ejecute la optimización op (backprop) y el costo op (para obtener el valor de pérdida) _, c = sess.run ([optimizer, cost], feed_dict = {x: batch_x, y: batch_y}) # Calcular la pérdida promedio avg_cost + = c / total_batch # Mostrar registros por paso de época si epoch% display_step == 0: correct_prediction = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Calcula la precisión = tf.reduce_mean (tf.cast (correct_prediction, 'float') ) acu_temp = precision.eval ({x: mnist.test.images, y: mnist.test.labels}) #agregue la precisión a la lista precision_history.append (acu_temp) #agregue el historial de costos cost_history.append (avg_cost) print ('Época:', '% 04d'% (época + 1), '- costo =', '{: .9f}'. Formato (avg_cost), '- Precisión =', acu_temp) print ('Optimización terminada! ') #trace el historial de costos plt.plot (cost_history) plt.show () #trace el historial de precisión plt.plot (precision _history) plt.show () # Modelo de prueba correct_prediction = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Calcular precisión precisión = tf.reduce_mean (tf.cast (correct_prediction, ' float ')) print (' Precisión: ', exactitud.eval ({x: mnist.test.images, y: mnist.test.labels}))

Salida:

Ahora con esto, llegamos al final de este artículo de Deep Learning con Python. Espero que haya comprendido los distintos componentes del aprendizaje profundo, cómo comenzó todo y cómo, con Python, podemos crear un perceptrón simple y una red neuronal profunda.

Edureka's está comisariada por profesionales de la industria según los requisitos y demandas de la industria. Dominará los conceptos como la función SoftMax, Autoencoder Neural Networks, Restricted Boltzmann Machine (RBM) y trabajará con bibliotecas como Keras y TFLearn. El curso ha sido especialmente comisariado por expertos de la industria con estudios de casos en tiempo real.

Tienes una pregunta para nosotros? Menciónelo en la sección de comentarios de 'Aprendizaje profundo con Python' y nos comunicaremos con usted.