Глубокое обучение - одна из самых горячих тем 2018–2019 годов, и не зря. В отрасли было так много достижений, что настало время, когда машины или компьютерные программы фактически вытеснили людей. Эта статья Глубокое обучение с помощью Python поможет вам понять, что такое глубокое обучение и как этот переход стал возможен. В этой статье я затрону следующие темы:
- Наука о данных и ее компоненты
- Потребность в глубоком обучении
- Что такое глубокое обучение?
- Персептрон и искусственные нейронные сети
- Приложения глубокого обучения
- Почему Python для глубокого обучения?
- Глубокое обучение с помощью Python: пример персептрона
- Глубокое обучение с помощью Python: создание глубокой нейронной сети
Наука о данных и ее компоненты
Что ж, Data Science существует уже много лет. Наука о данных - это извлечение знаний из данных с использованием различных методов и алгоритмов.
Искусственный интеллект - это метод, позволяющий машинам имитировать поведение человека. Идея искусственного интеллекта довольно проста, но увлекательна: создание интеллектуальных машин, способных принимать решения самостоятельно. В течение многих лет считалось, что компьютеры никогда не смогут сравниться по мощности с человеческим мозгом.
Что ж, тогда у нас не было достаточно данных и вычислительной мощности, но теперь, когда появились большие данные и с появлением графических процессоров, искусственный интеллект стал возможен.
Машинное обучение - это разновидность технологии искусственного интеллекта, в которой используются статистические методы, позволяющие машинам совершенствоваться с приобретением опыта.
Глубокое обучение - это подмножество машинного обучения, которое делает возможным вычисление многослойной нейронной сети. Он использует нейронные сети для имитации принятия решений человеком.
Потребность в глубоком обучении
Шаг к искусственному интеллекту - машинное обучение. Машинное обучение - это разновидность искусственного интеллекта, основанная на идее о том, что машинам должен быть предоставлен доступ к данным и что их следует оставить для самостоятельного изучения и изучения. Он занимается извлечением шаблонов из больших наборов данных. Обработка больших наборов данных не была проблемой.
- Алгоритмы машинного обучения не могут обрабатывать многомерные данные - там, где у нас есть большое количество входов и выходов: круглые тысячи измерений. Обработка такого типа данных становится очень сложной и ресурсоемкой. Это называется Проклятие размерности.
- Еще одна проблема заключалась в том, чтобы указать объекты, которые нужно извлечь. Это играет важную роль в прогнозировании результата, а также в достижении большей точности. Следовательно, без извлечения признаков проблема для программиста возрастает, поскольку эффективность алгоритма во многом зависит от того, насколько проницателен программист.
Вот где на помощь пришло глубокое обучение. Глубокое обучение способно обрабатывать многомерные данные, а также эффективно, фокусируясь на правильных функциях само по себе.
Что такое глубокое обучение?
Глубокое обучение - это подмножество машинного обучения, в котором аналогичные алгоритмы машинного обучения используются для обучения глубоких нейронных сетей, чтобы добиться большей точности в тех случаях, когда первые не работали должным образом. По сути, глубокое обучение имитирует работу нашего мозга, т. Е. Учится на собственном опыте.
Как вы знаете, наш мозг состоит из миллиардов нейронов, которые позволяют нам делать удивительные вещи. Даже мозг маленького ребенка способен решать сложные задачи, которые очень сложно решить даже с помощью суперкомпьютеров. Итак, как мы можем достичь той же функциональности в программе? Здесь мы понимаем искусственный нейрон (персептрон) и искусственную нейронную сеть.
Персептрон и искусственные нейронные сети
Глубокое обучение изучает базовую единицу мозга, называемую клеткой мозга или нейроном. Теперь давайте поймем функциональность биологических нейронов и то, как мы имитируем эту функциональность в восприятии или искусственном нейроне.
- Дендрит: принимает сигналы от других нейронов.
- Тело ячейки: суммирует все входные данные.
- Axon: он используется для передачи сигналов другим клеткам.
Искусственный нейрон или персептрон - это линейная модель, используемая для бинарной классификации. Он моделирует нейрон, который имеет набор входов, каждому из которых присваивается определенный вес. Нейрон вычисляет некоторую функцию на этих взвешенных входах и выдает результат.
Он получает n входов (соответствующих каждой функции). Затем он суммирует эти входные данные, применяет преобразование и выдает результат. Он выполняет две функции:
- Суммирование
- Трансформация (активация)
Вес показывает эффективность того или иного входа. Чем больше вес ввода, тем сильнее он повлияет на нейронную сеть. С другой стороны, Смещение - это дополнительный параметр в персептроне, который используется для настройки вывода вместе с взвешенной суммой входов нейрона, что помогает модели в таким образом, чтобы он лучше всего подходил для заданных данных.
Функции активации преобразует входы в выходы. Он использует порог для вывода. В качестве функций активации используется множество функций, например:
- Линейность или идентичность
- Единица или двоичный шаг
- Сигмовидная или логистическая
- Тань
- ReLU
- Софтмакс
Хорошо. если вы думаете, что Perceptron решает проблему, то вы ошибаетесь. Были две основные проблемы:
- Однослойные персептроны не могут классифицировать нелинейно разделимые точки данных.
- Однослойные персептроны не могут решить сложные задачи, которые включают множество параметров.
Рассмотрим приведенный здесь пример и сложность параметров, необходимых для принятия решения маркетинговой командой.
Один нейрон не может принимать столько входных сигналов, поэтому для решения этой проблемы можно использовать более одного нейрона. Нейронная сеть - это просто состав перцептронов, связанных разными способами и выполняющих разные функции активации.
- Узлы ввода предоставляют информацию из внешнего мира в сеть и вместе называются «Уровень ввода».
- Скрытые узлы выполняют вычисления и передают информацию от входных узлов к выходным узлам. Набор скрытых узлов образует «Скрытый слой».
- Узлы вывода вместе называются «Уровень вывода» и отвечают за вычисления и передачу информации из сети во внешний мир.
Теперь, когда у вас есть представление о том, как ведет себя перцептрон, о различных задействованных параметрах и о разных уровнях нейронной сети, давайте продолжим этот блог Deep Learning with Python и рассмотрим несколько интересных приложений Deep Learning.
Приложения глубокого обучения
В отрасли существуют различные применения глубокого обучения, вот некоторые из наиболее важных из них, которые присутствуют в наших повседневных задачах.
- Распознавание речи
- Машинный перевод
- Распознавание лиц и автоматическая маркировка
- Виртуальные личные помощники
- Самостоятельная машина
- Чат-боты
Почему Python для глубокого обучения?
- Python - один из таких инструментов, обладающий уникальным свойством: язык программирования общего назначения, который прост в использовании, когда дело доходит до аналитических и количественные вычисления.
- Это очень легко понять
- Python динамически типизирован
- Огромная поддержка сообщества
- Огромный выбор библиотек для различных целей, таких как Numpy, Seaborn, Matplotlib, Pandas и Scikit-learn.
Теперь достаточно теории. Давайте посмотрим, как мы можем начать глубокое обучение с помощью Python на небольшом, но захватывающем примере.
Пример персептрона
Теперь я уверен, что вы, ребята, должны быть знакомы с работой ворот «ИЛИ». На выходе будет 1, если любой из входов также равен 1.
Следовательно, перцептрон можно использовать в качестве разделителя или линии решения, которая разделяет входной набор логического элемента ИЛИ на два класса:
Класс 1: входы с выходом 0, расположенным ниже линии решения.
Класс 2: входы с выходом 1, расположенным над линией решения или разделителем.
До сих пор мы понимали, что линейный персептрон можно использовать для классификации набора входных данных на два класса. Но как он на самом деле классифицирует данные?
Математически перцептрон можно представить себе как уравнение весов, входных данных и смещения.
Шаг 1. Импортируйте всю необходимую библиотеку
Здесь я собираюсь импортировать только одну библиотеку, т.е. TensorFlow
import tensorflow as tf
Шаг 2. Определите векторные переменные для ввода и вывода
Затем нам нужно создать переменные для хранения ввода, вывода и смещения для перцептрона.
train_in = [ [0,0,1], [0,1,1], [1,0,1], [1,1,1]] train_out = [ [0], [1], [1], [1]]
Шаг 3. Определите переменную веса
Здесь мы определим тензорную переменную формы 3 × 1 для наших весов и сначала присвоим ей некоторые случайные значения.
w = tf.Variable(tf.random_normal([3, 1], seed=15))
Шаг 4. Определите заполнители для ввода и вывода
Нам нужно определить заполнители, чтобы они могли принимать внешние входные данные во время выполнения.
x = tf.placeholder(tf.float32,[None,3]) y = tf.placeholder(tf.float32,[None,1])
Шаг 5: Расчет мощности и функции активации
Как обсуждалось ранее, входные данные, полученные перцептроном, сначала умножаются на соответствующие веса, а затем все эти взвешенные входные данные суммируются. Это суммарное значение затем подается на активацию для получения окончательного результата.
output = tf.nn.relu(tf.matmul(x, w))
Примечание. В этом случае я использовал relu в качестве функции активации. Вы можете использовать любую из функций активации в соответствии с вашими потребностями.
Шаг 6. Рассчитайте стоимость или ошибку
Нам нужно вычислить стоимость = среднеквадратичную ошибку, которая представляет собой не что иное, как квадрат разницы выходного сигнала персептрона и желаемого выходного сигнала.
loss = tf.reduce_sum(tf.square(output - y))
Шаг 7. Минимизируйте ошибку
Цель перцептрона - минимизировать потерю, стоимость или ошибку. Итак, здесь мы собираемся использовать оптимизатор градиентного спуска.
optimizer = tf.train.GradientDescentOptimizer(0.01) train = optimizer.minimize(loss)
Шаг 8: инициализируйте все переменные
Переменные определяются только с помощью tf.Variable. Итак, нам нужно инициализировать определенные переменные.
init = tf.global_variables_initializer() sess = tf.Session() sess.run(init)
Шаг 9: обучение персептрона в итерациях
Нам нужно обучить наш перцептрон, то есть обновлять значения весов и смещения в последовательной итерации, чтобы минимизировать ошибку или потерю. Здесь я обучу наш перцептрон за 100 эпох.
for i in range(100):
sess.run(train, {x:train_in,y:train_out})
cost = sess.run(loss,feed_dict={x:train_in,y:train_out})
print('Epoch--',i,'--loss--',cost)
Шаг 10: Вывод
Как видите, убыток начался с 2,07 и закончился на уровне 0,27.
Создание глубокой нейронной сети
Теперь, когда мы успешно создали перцептрон и обучили его работе с воротами ИЛИ. Давайте продолжим эту статью и посмотрим, как создать нашу собственную нейронную сеть с нуля, где мы создадим входной слой, скрытые слои и выходной слой.
Мы собираемся использовать набор данных MNIST. Набор данных MNIST состоит из 60 000 обучающих образцов и 10 000 тестовых образцов рукописных изображений цифр. Изображения имеют размер 28 × 28 пикселей, а изображение на выходе может находиться в диапазоне 0–9.
Задача состоит в том, чтобы обучить модель, которая сможет точно идентифицировать цифру, присутствующую на изображении
Во-первых, мы собираемся использовать приведенный ниже импорт, чтобы перенести функцию печати из Python 3 в Python 2.6+. Операторы __future__ должны находиться в верхней части файла, потому что они меняют фундаментальные аспекты языка, и поэтому компилятор должен знать о них с самого начала.
from __future__ import print_function
Ниже приведен код с комментариями на каждом этапе.
# Import MNIST data
from 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
# Parameters
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 digits)
# tf Graph input
x = tf.placeholder("float", [None, n_input])
y = tf.placeholder("float", [None, n_classes])
# Create model
def multilayer_perceptron(x, weights, biases):
# Hidden layer with RELU activation
layer_1 = tf.add(tf.matmul(x, weights['h1']), biases['b1'])
layer_1 = tf.nn.relu(layer_1)
# Hidden layer with RELU activation
layer_2 = tf.add(tf.matmul(layer_1, weights['h2']), biases['b2'])
layer_2 = tf.nn.relu(layer_2)
# Output layer with linear activation
out_layer = tf.matmul(layer_2, weights['out']) + biases['out']
return out_layer
# Store layers weight & bias
weights = {
'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, weights, biases)
# Define loss and optimizer
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred, labels=y))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)
# Initializing the variables
init = tf.global_variables_initializer()
#create an empty list to store the cost history and accuracy history
cost_history = []
accuracy_history = []
# Launch the graph
with tf.Session() as sess:
sess.run(init)
# Training cycle
for epoch in range(training_epochs):
avg_cost = 0.
total_batch = int(mnist.train.num_examples/batch_size)
# Loop over all batches
for i in range(total_batch):
batch_x, batch_y = mnist.train.next_batch(batch_size)
# Run optimization op (backprop) and cost op (to get loss value)
_, c = sess.run([optimizer, cost], feed_dict={x: batch_x,y: batch_y})
# Compute average loss
avg_cost += c / total_batch
# Display logs per epoch step
if epoch % display_step == 0:
correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))
# Calculate accuracy
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
acu_temp = accuracy.eval({x: mnist.test.images, y: mnist.test.labels})
#append the accuracy to the list
accuracy_history.append(acu_temp)
#append the cost history
cost_history.append(avg_cost)
print("Epoch:", '%04d' % (epoch + 1), "- cost=", "{:.9f}".format(avg_cost), "- Accuracy=",acu_temp)
print("Optimization Finished!")
#plot the cost history
plt.plot(cost_history)
plt.show()
#plot the accuracy history
plt.plot(accuracy_history)
plt.show()
# Test model
correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))
# Calculate accuracy
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
print("Accuracy:", accuracy.eval({x: mnist.test.images, y: mnist.test.labels}))
Вывод:
На этом мы подошли к концу статьи «Глубокое обучение с помощью Python». Надеюсь, вы получили представление о различных компонентах глубокого обучения, о том, как все началось и как с помощью Python можно создать простой перцептрон и глубокую нейронную сеть.
Если вы хотите ознакомиться с другими статьями о самых популярных технологиях на рынке, таких как искусственный интеллект, DevOps, этический взлом, посетите официальный сайт Edureka.
Обязательно обратите внимание на другие статьи в этой серии, которые объяснят различные другие аспекты глубокого обучения.
17. Q Learning
18. Априорный алгоритм.
23. Вопросы на собеседовании по искусственному интеллекту (ИИ)
Первоначально опубликовано на www.edureka.co 19 февраля 2019 г.
