Автор оригинала: Matthew Corrigan.
Все, у кого есть слух в мире технологий, слышали о машинном обучении . Она известна как высокоинтеллектуальная и математическая область исследований, которая практикуется только самыми учеными программистами. Общее мнение таково, что вам нужно знать математическое исчисление, чтобы иметь возможность создавать что-либо, напоминающее машинное обучение. Напротив, эта статья поможет вам создать персептрон на Python без какой-либо продвинутой математической теории и менее чем в 60 строках кода.
Что такое Восприятие?
Персептрон использует основные идеи машинного обучения и нейронных сетей. Идея заключается в том, что вы передаете программе кучу входных данных, и она учится обрабатывать эти входные данные в выходные данные. Он делает это, присваивая каждому входу вес. Каждый вход умножается на этот вес и суммируется вместе. Наконец, нам нужно превратить эту сумму в значение: 1 или -1. При обучении персептрона мы оцениваем выходные данные, которые генерирует наша программа, и корректируем наши веса на основе того, что должны были выдавать входные данные. По сути, персептроны могут помочь нам классифицировать данные. Не волнуйтесь, если это объяснение вас смутило, вы начнете понимать, когда мы начнем кодировать.
Кодирование класса Персептронов
Мы должны начать с создания класса персептронов. В функции инициализатора мы хотим инициализировать наши веса, каждый из которых начинается как случайное число между -1 и 1. Для генерации случайных чисел мы будем использовать random.random() , который возвращает число от 0 до 1.
import random
class Perceptron:
def __init__(self, learn_speed, num_weights):
self.speed = learn_speed
self.weights = []
for x in range(0, num_weights):
self.weights.append(random.random()*2-1)
Первый параметр, learn_speed , используется для управления скоростью обучения нашего персептрона. Чем ниже значение, тем больше времени потребуется для обучения, но тем меньше одно значение изменит каждый общий вес. Если этот параметр слишком высок, наша программа изменит свои веса так быстро, что они будут неточными. С другой стороны, если learn_speed слишком низкая, потребуется вечность, чтобы точно обучить персептрон. Хорошее значение для этого параметра составляет около 0,01-0,05.
Второй параметр, num_weights , определяет, сколько весов будет иметь персептрон. Наше восприятие также будет иметь такое же количество входов, как и вес, потому что каждый вход имеет свой собственный вес.
Затем нам нужно создать функцию в нашем классе, чтобы принимать входные данные и превращать их в выходные данные. Мы делаем это, умножая каждый вход на его соответствующий вес, суммируя все вместе, а затем проверяя, больше ли сумма 0. В вашем классе персептронов добавьте этот код после функции __init__ :
def feed_forward(self, inputs):
sum = 0
# multiply inputs by weights and sum them
for x in range(0, len(self.weights)):
sum += self.weights[x] * inputs[x]
# return the 'activated' sum
return self.activate(sum)
def activate(self, num):
# turn a sum over 0 into 1, and below 0 into -1
if num > 0:
return 1
return -1
Приведенный выше код является основой для нашего восприятия. Если вы сможете очень хорошо понять этот код, у вас будет фантастическое понимание основ машинного обучения. Давайте разберем этот код по частям.
Первая функция, feed_forward , используется для преобразования входов в выходы. Термин feedforward обычно используется в нейронных сетях для описания этого процесса превращения входных данных в выходные. Этот метод взвешивает каждый вход на основе каждого соответствующего веса. Он суммирует их, а затем использует функцию activate, чтобы вернуть либо 1, либо -1.
Функция activate используется для преобразования числа в 1 или -1. Это реализовано потому, что, когда мы используем персептрон, мы хотим классифицировать данные. Мы классифицируем его на две группы, одна из которых представлена 1, а другая -1.
Вы можете задаться вопросом: “Какой в этом смысл, если веса случайны?” Вот почему мы должны тренировать персептрон, прежде чем использовать его. В нашей функции train мы хотим сделать предположение на основе предоставленных входных данных, а затем посмотреть, как наше предположение сравнивается с желаемым результатом. Функция поезда для класса персептронов показана ниже.
def train(self, inputs, desired_output):
guess = self.feed_forward(inputs)
error = desired_output - guess
for x in range(0, len(self.weights)):
self.weights[x] += error*inputs[x]*self.speed
Большая часть первых нескольких строк должна иметь смысл. Наша функция принимает входные данные и выходные данные, которые должны произойти, когда мы запускаем входные данные через нашу программу. Мы делаем предположение о входных данных, используя нашу функцию feed_forward , а затем вычисляем нашу ошибку на основе того, что мы должны были вывести. Обратите внимание, что если мы правильно спрогнозировали, ошибка будет равна 0, и последняя строка нашей функции вообще не изменит наши веса.
Последние две строки этой функции являются самой пикантной частью — они помещают обучение в машинное обучение. Мы перебираем каждый вес и корректируем его по тому, сколько ошибок у нас было. Обратите внимание, что здесь мы используем переменную self.speed , которая определяет, как быстро учится персептрон. Запустив эту функцию обучения на множестве входов и их выходов, мы можем в конечном итоге научить наш персептрон получать правильный вывод.
Тренировка Персептрона
Наше восприятие бесполезно, если мы на самом деле не тренируем его. Мы сделаем это, написав быстрый класс тренера. В этом примере мы научим наш персептрон определять, находится ли точка выше линии или ниже линии. Наша линия, в данном случае, представлена уравнением.5x + 10. Как только вы узнаете, как обучить персептрон распознавать линию, вы можете представить x и y как разные атрибуты, а выше или ниже линии-как результаты этих атрибутов.
Например, если бы у вас был набор данных о баллах GPA и ACT абитуриентов Гарварда, и независимо от того, были ли они приняты или нет, вы могли бы обучить персептрон находить линию на графике, где оценка и оценка. Выше линии будут студенты, которые были приняты, а ниже линии будут студенты, которые были отклонены. Затем вы можете использовать этот персептрон, чтобы предсказать, будет ли студент принят в Гарвард на основе его среднего балла и баллов ACT.
В этом примере мы будем придерживаться распознавания линии. Для этого мы создадим класс тренажеров, который обучает персептрон с точками и независимо от того, находятся ли они выше линии. Ниже приведен код для нашего класса тренера:
class Trainer:
def __init__(self):
self.perceptron = Perceptron(0.01, 3)
def f(self, x):
return 0.5*x + 10 # line: f(x) = 0.5x + 10
def train(self):
for x in range(0, 1000000):
x_coord = random.random()*500-250
y_coord = random.random()*500-250
line_y = self.f(x_coord)
if y_coord > line_y: # above the line
answer = 1
self.perceptron.train([x_coord, y_coord,1], answer)
else: # below the line
answer = -1
self.perceptron.train([x_coord, y_coord,1], answer)
return self.perceptron # return our trained perceptron
Как вы можете видеть, инициализатор для класса Trainer создает персептрон с тремя входами и скоростью обучения 0,01. Первые два входа-это x и y, но каков последний вход? Это еще одна ключевая концепция нейронных сетей и машинного обучения. Этот последний ввод всегда будет равен 1. Вес, соответствующий ему, определит, как он повлияет на нашу линию. Например, если вы оглянетесь на наше уравнение:.5x + 10, нам нужен какой-то способ представления y-перехвата, 10. Мы делаем это, создавая третий вход, который увеличивается или уменьшается в зависимости от веса, который перцептрон обучает его иметь. Думайте об этом как о пороге, который помогает персептрону понять, что линия настроена на 10 единиц вверх.
В нашей функции f мы берем координату x и возвращаем координату y. Это используется для поиска точек на линии на основе их координаты x, что пригодится в следующей функции.
Эта функция train для класса Trainer-это то, где происходит все волшебство, и мы действительно тренируем наш персептрон. Мы начинаем с цикла 1 миллион раз. Помните, как у нас была скорость обучения для нашего восприятия? Чем больше раз мы тренируем наш персептрон (в данном случае 1 миллион раз), тем более точным он станет, даже при низкой скорости обучения.
На каждой итерации цикла мы создаем точку, определяем, находится ли она выше или ниже линии, а затем вводим эти входные данные в метод train персептрона. Во-первых, координаты x и y генерируются случайным образом в диапазоне от -250 до 250. Затем мы находим, где координата y будет находиться на линии для этого значения x, чтобы увидеть, находится ли ваша точка над линией. Например, если мы выбрали точку в (1, 3), то мы должны получить координату y линии для значения x 3. Мы делаем это с помощью нашей функции f . Если наша случайная координата y выше соответствующей координаты y на линии, мы знаем, что наша случайная координата выше линии.
Это то, что мы делаем в операторе if...else . Если наша точка находится выше линии, мы устанавливаем ожидаемый результат, сохраненный в answer , равным 1. Если наша точка находится ниже линии, наш ожидаемый результат равен -1. Затем мы тренируем наш персептрон на основе координат x, y и ожидаемого результата. После завершения всего цикла мы возвращаем наш недавно обученный объект персептрона.
Запуск программы
Чтобы запустить программу, мы создаем объект trainer и вызываем его .train() метод.
trainer = Trainer() p = trainer.train()
Теперь о моменте славы; мы запускаем программу. Давайте выберем две точки (-7, 9) и (3, 1). Первая точка находится выше линии, поэтому она должна возвращать 1, а вторая-ниже линии, поэтому она должна возвращать -1. Давайте посмотрим, как мы будем управлять нашим персептроном:
print "(-7, 9): " + p.feed_forward([-7,9,1]) print "(3, 1): " + p.feed_forward([3,1,1])
И если мы запустим его:
(-7, 9): 1 (3, 1): -1
Успех! Наша программа определила, находится ли каждая точка выше или ниже линии. Вы можете попробовать больше очков, чтобы проверить для себя, что программа работает правильно.
Обертывание
Эта статья предназначена в качестве отправной точки, чтобы помочь вам понять некоторые основы машинного обучения, в частности, с нейронными сетями. Если вы хотите углубиться в эту тему, ознакомьтесь с некоторыми из этих ссылок: