Как написать персептрон на python

Я написал уникальный, не имеющий аналогов в мире однослойный персептрон без использования сторонних модулей. Для чего? Что бы всем показывать свою статью на Хабрахабре, очевидно же. Это не перевод и не копия чьей-нибудь статьи, всё своё.

Итак, весь код:

import random

def train(X, y, syn0, lens0, lens01, lr):
    errorreturn = 0
    for i in range(0, lens0):
        a = 0
        for j in range(0, lens01):
            a = a + syn0[i][j] * X[j]
        b = 1 / (1 + 2.718281828459045235360287471352662497757 ** -a)
        error = y[i] - b
        errorreturn = errorreturn + abs(error)
        delta = (error) * 1 / (1 + 2.718281828459045235360287471352662497757 ** -b) * lr
        for z in range(0, lens01):
            syn0[i][z] = syn0[i][z] + X[z] * delta
    return syn0, errorreturn

def predict(syn0, X, lens0, lens01):
    ret = []
    for i in range(0, lens0):
        a = 0
        for j in range(0, lens01):
            a = a + syn0[i][j] * X[j]
        b = 1 / (1 + 2.718281828459045235360287471352662497757 ** -a)
        ret.append(b)
    return ret

def trainmass(X, y, syn, lens0, lens01, lr, iter):
    for i in range(iter):
        for j in range(lens01):
            syn, er = train(X[j], y[j], syn, lens0, lens01, lr)
    return syn, er

def create(x, y):
    syn0 = []
    for z in range(0, x):
        h = []
        for i in range(0, y):
            h.append(random.uniform(-0.1, 0.1))
        syn0.append(h)
    return syn0

syn = create(2, 4)
X = [[0.1, 0.2, 0.3, 0.4],[0.2, 0.3, 0.4, 0.5],[0.4, 0.5, 0.6, 0.7],[0.5,0.6,0.7,0.8]]
y = [[0.5, 0.6],[0.6, 0.7],[0.8, 0.9],[0.9, 1]]
g, r = trainmass(X, y, syn, 2, 4, 1, 60000)
h = predict(syn, X[0], 2, 4)
h2 = predict(syn, [0.5, 0.6, 0.7, 0.8], 2, 4)
print(h)
print(h2)

Функция train — обучает, predict — обрабатывает входные данные уже обученными синапсами и выдает ответ, trainmass — запускает обучение по всем входным данным(2 — это количество выходных данных, 4 — количество данных в примере, 1 — это лерн рейт, 60000 — количество циклов обучения), create — создает массив случайных синапсов для обучения.

В этом примере массив X имеет 4 набора данных и массив y 4 набора выходных данных.

После запуска имеем вывод:

[0.4835439912709079, 0.5593653075469635]
[0.8848108739666853, 0.9682956213528969]

Первый массив — это ответ на входные данные X[0] — [0.1, 0.2, 0.3, 0.4].
Второй массив — это ответ на данные которые не были в обучающей выборке [0.5, 0.6, 0.7, 0.8].

Как видите персептрон продолжил числовой ряд почти верно с небольшими отклонениями.
Немного разберем принцип его работы. Персептрон получает что-то похожее на систему линейных уравнений:

0.1*x1 + 0.2*x2 + 0.3*x3 + 0.4*x4 = 0.5
0.2*x1 + 0.3*x2 + 0.4*x3 + 0.5*x4 = 0.6
0.4*x1 + 0.5*x2 + 0.6*x3 + 0.7*x4 = 0.8
0.5*x1 + 0.6*x2 + 0.7*x3 + 0.8*x4 = 0.9

И методом обратного распространения ошибки находит соответствующие x1, x2, x3, x4.
Для второго выходного значения создаются другие y1, y2, y3, y4.

Я не стану описывать функцию активации — сигмоид. Если вы разберетесь в этом простом коде вам станет понятно.

Однослойный персептрон может решать только линейные задачи. Для нелинейности нужно добавить еще слой или несколько слоев. Если будет много комментариев, я напишу двухслойную модель.

  Перевод

  Ссылка на автора

Алгоритм Perceptron — это самый простой тип искусственной нейронной сети.

Это модель одного нейрона, которая может использоваться для задач классификации двух классов и обеспечивает основу для дальнейшей разработки гораздо более крупных сетей.

В этом руководстве вы узнаете, как реализовать алгоритм Perceptron с нуля с помощью Python.

После завершения этого урока вы узнаете:

• Как тренировать сетевые веса для Перцептрона.
• Как делать прогнозы с помощью Перцептрона.
• Как реализовать алгоритм Персептрон для реальной задачи классификации.

Давайте начнем.

• Обновление январь / 2017: Изменено вычисление fold_size в cross_validation_split (), чтобы оно всегда было целым числом. Исправляет проблемы с Python 3.
• Обновление Авг / 2018: Протестировано и обновлено для работы с Python 3.6.

Описание

В этом разделе дается краткое введение в алгоритм Perceptron и набор данных Sonar, к которым мы позже применим его.

Алгоритм персептрона

Перцептрон вдохновлен обработкой информации одной нервной клетки, называемой нейроном.

Нейрон принимает входные сигналы через свои дендриты, которые передают электрический сигнал в тело клетки.

Аналогичным образом, Perceptron получает входные сигналы от примеров тренировочных данных, которые мы взвешиваем и объединяем в линейное уравнение, называемое активацией.

activation = sum(weight_i * x_i) + bias

Затем активация преобразуется в выходное значение или прогноз с использованием передаточной функции, такой как пошаговая передаточная функция.

prediction = 1.0 if activation >= 0.0 else 0.0

Таким образом, Перцептрон является алгоритмом классификации для задач с двумя классами (0 и 1), где линейное уравнение (например, или гиперплоскость) может использоваться для разделения двух классов.

Это тесно связано с линейной регрессией и логистической регрессией, которые делают предсказания аналогичным образом (например, взвешенная сумма входных данных).

Вес алгоритма Perceptron должен быть оценен на основе ваших тренировочных данных с использованием стохастического градиентного спуска.

Стохастический градиентный спуск

Градиентный спуск — это процесс минимизации функции, следуя градиентам функции стоимости.

Это включает в себя знание формы стоимости, а также производной, чтобы из заданной точки вы знали градиент и могли двигаться в этом направлении, например, вниз к минимальному значению.

В машинном обучении мы можем использовать технику, которая оценивает и обновляет веса на каждой итерации, называемую стохастическим градиентным спуском, чтобы минимизировать ошибку модели в наших обучающих данных.

Этот алгоритм оптимизации работает так, что каждый обучающий экземпляр показывается модели по одному. Модель делает прогноз для обучающего экземпляра, вычисляется ошибка, и модель обновляется, чтобы уменьшить ошибку для следующего прогнозирования.

Эта процедура может использоваться, чтобы найти набор весов в модели, который приводит к наименьшей ошибке для модели в данных обучения.

Для алгоритма Perceptron каждая итерация весов (вес) обновляются с использованием уравнения:

w = w + learning_rate * (expected - predicted) * x

кудавесвес оптимизируется,learning_rateэто скорость обучения, которую вы должны настроить (например, 0,01),(ожидается — предсказано)ошибка прогноза для модели на тренировочных данных, отнесенных к весу иИксэто входное значение.

Сонар Набор данных

Набор данных, который мы будем использовать в этом уроке, — это набор данных Sonar.

Это набор данных, который описывает возврат эхолота, отраженный от разных служб. 60 входных переменных — это сила отдачи под разными углами. Это проблема бинарной классификации, которая требует модели для дифференциации горных пород от металлических цилиндров.

Это хорошо понятный набор данных. Все переменные являются непрерывными и обычно находятся в диапазоне от 0 до 1. Таким образом, нам не нужно будет нормализовать входные данные, что часто является хорошей практикой в ​​алгоритме Perceptron. Выходная переменная — это строка «M» для моего и «R» для рока, которую необходимо преобразовать в целые числа 1 и 0.

Прогнозируя класс с наибольшим количеством наблюдений в наборе данных (M или мин), алгоритм нулевого правила может достичь точности 53%.

Вы можете узнать больше об этом наборе данных на UCI хранилище машинного обучения, Вы можете скачать набор данных бесплатно и поместить его в свой рабочий каталог с именем файлаsonar.all-data.csv,

Руководство

Этот урок разбит на 3 части:

1. Делать прогнозы.
2. Весы тренировочные сети.
3. Моделирование набора данных сонара.

Эти шаги дадут вам основу для реализации и применения алгоритма Perceptron к вашим собственным задачам прогнозного моделирования классификации.

1. Делать прогнозы

Первым шагом является разработка функции, которая может делать прогнозы.

Это будет необходимо как при оценке значений весов кандидатов при стохастическом градиентном спуске, так и после того, как модель будет завершена, и мы хотим начать делать прогнозы на тестовых данных или новых данных.

Ниже приведена функция с именемпредсказать, ()это предсказывает выходное значение для строки, заданной набором весов.

Первый вес всегда является смещением, поскольку он является автономным и не отвечает за конкретное входное значение.

# Make a prediction with weights
def predict(row, weights):
	activation = weights[0]
	for i in range(len(row)-1):
		activation += weights[i + 1] * row[i]
	return 1.0 if activation >= 0.0 else 0.0

Мы можем создать небольшой набор данных для проверки нашей функции прогнозирования.

X1			X2			Y
2.7810836		2.550537003		0
1.465489372		2.362125076		0
3.396561688		4.400293529		0
1.38807019		1.850220317		0
3.06407232		3.005305973		0
7.627531214		2.759262235		1
5.332441248		2.088626775		1
6.922596716		1.77106367		1
8.675418651		-0.242068655		1
7.673756466		3.508563011		1

Мы также можем использовать предварительно подготовленные веса, чтобы делать прогнозы для этого набора данных.

Собрав все это вместе, мы можем проверить нашипредсказать, ()функция ниже.

# Make a prediction with weights
def predict(row, weights):
	activation = weights[0]
	for i in range(len(row)-1):
		activation += weights[i + 1] * row[i]
	return 1.0 if activation >= 0.0 else 0.0

# test predictions
dataset = [[2.7810836,2.550537003,0],
	[1.465489372,2.362125076,0],
	[3.396561688,4.400293529,0],
	[1.38807019,1.850220317,0],
	[3.06407232,3.005305973,0],
	[7.627531214,2.759262235,1],
	[5.332441248,2.088626775,1],
	[6.922596716,1.77106367,1],
	[8.675418651,-0.242068655,1],
	[7.673756466,3.508563011,1]]
weights = [-0.1, 0.20653640140000007, -0.23418117710000003]
for row in dataset:
	prediction = predict(row, weights)
	print("Expected=%d, Predicted=%d" % (row[-1], prediction))

Есть два входных значения (X1а такжеX2) и три значения веса (смещение,w1а такжеw2). Уравнение активации, которое мы смоделировали для этой задачи:

activation = (w1 * X1) + (w2 * X2) + bias

Или с конкретными значениями веса, которые мы выбрали вручную, как:

activation = (0.206 * X1) + (-0.234 * X2) + -0.1

Запустив эту функцию, мы получим прогнозы, которые соответствуют ожидаемому результату (Y) ценности.

Expected=0, Predicted=0
Expected=0, Predicted=0
Expected=0, Predicted=0
Expected=0, Predicted=0
Expected=0, Predicted=0
Expected=1, Predicted=1
Expected=1, Predicted=1
Expected=1, Predicted=1
Expected=1, Predicted=1
Expected=1, Predicted=1

Теперь мы готовы реализовать стохастический градиентный спуск, чтобы оптимизировать наши значения веса.

2. Веса тренировочной сети

Мы можем оценить значения веса для наших тренировочных данных, используя стохастический градиентный спуск.

Стохастический градиентный спуск требует двух параметров:

• Скорость обучения: Используется для ограничения количества, которое корректируется каждый вес при каждом обновлении.
• Эпохи: Сколько раз пробегать данные тренировки при обновлении веса.

Они вместе с данными обучения будут аргументами функции.

В функции нам нужно выполнить 3 цикла:

1. Зацикливайтесь на каждой эпохе.
2. Зацикливайтесь на каждой строке в данных тренировки для определенной эпохи.
3. Переберите каждый вес и обновите его для ряда в эпоху.

Как видите, мы обновляем каждый вес для каждой строки в тренировочных данных, каждую эпоху.

Веса обновляются в зависимости от ошибки, допущенной моделью. Ошибка рассчитывается как разница между ожидаемым выходным значением и прогнозом, сделанным с использованием весов-кандидатов.

Существует один вес для каждого входного атрибута, и они обновляются согласованным образом, например:

w(t+1)= w(t) + learning_rate * (expected(t) - predicted(t)) * x(t)

Смещение обновляется аналогичным образом, за исключением того, что без ввода, поскольку оно не связано с конкретным значением ввода:

bias(t+1) = bias(t) + learning_rate * (expected(t) - predicted(t))

Теперь мы можем собрать все это вместе. Ниже приведена функция с именемtrain_weights ()который вычисляет значения веса для учебного набора данных с использованием стохастического градиентного спуска.

# Estimate Perceptron weights using stochastic gradient descent
def train_weights(train, l_rate, n_epoch):
	weights = [0.0 for i in range(len(train[0]))]
	for epoch in range(n_epoch):
		sum_error = 0.0
		for row in train:
			prediction = predict(row, weights)
			error = row[-1] - prediction
			sum_error += error**2
			weights[0] = weights[0] + l_rate * error
			for i in range(len(row)-1):
				weights[i + 1] = weights[i + 1] + l_rate * error * row[i]
		print('>epoch=%d, lrate=%.3f, error=%.3f' % (epoch, l_rate, sum_error))
	return weights

Вы можете видеть, что мы также отслеживаем сумму квадратов ошибок (положительное значение) для каждой эпохи, чтобы мы могли распечатать хорошее сообщение в каждом внешнем цикле.

Мы можем протестировать эту функцию на том же небольшом измышленном наборе данных сверху.

# Make a prediction with weights
def predict(row, weights):
	activation = weights[0]
	for i in range(len(row)-1):
		activation += weights[i + 1] * row[i]
	return 1.0 if activation >= 0.0 else 0.0

# Estimate Perceptron weights using stochastic gradient descent
def train_weights(train, l_rate, n_epoch):
	weights = [0.0 for i in range(len(train[0]))]
	for epoch in range(n_epoch):
		sum_error = 0.0
		for row in train:
			prediction = predict(row, weights)
			error = row[-1] - prediction
			sum_error += error**2
			weights[0] = weights[0] + l_rate * error
			for i in range(len(row)-1):
				weights[i + 1] = weights[i + 1] + l_rate * error * row[i]
		print('>epoch=%d, lrate=%.3f, error=%.3f' % (epoch, l_rate, sum_error))
	return weights

# Calculate weights
dataset = [[2.7810836,2.550537003,0],
	[1.465489372,2.362125076,0],
	[3.396561688,4.400293529,0],
	[1.38807019,1.850220317,0],
	[3.06407232,3.005305973,0],
	[7.627531214,2.759262235,1],
	[5.332441248,2.088626775,1],
	[6.922596716,1.77106367,1],
	[8.675418651,-0.242068655,1],
	[7.673756466,3.508563011,1]]
l_rate = 0.1
n_epoch = 5
weights = train_weights(dataset, l_rate, n_epoch)
print(weights)

Мы используем скорость обучения 0,1 и обучаем модель только для 5 эпох, или 5 воздействий весов на весь набор обучающих данных.

При выполнении примера в каждую эпоху печатается сообщение с ошибкой суммы квадратов для этой эпохи и окончательным набором весов.

>epoch=0, lrate=0.100, error=2.000
>epoch=1, lrate=0.100, error=1.000
>epoch=2, lrate=0.100, error=0.000
>epoch=3, lrate=0.100, error=0.000
>epoch=4, lrate=0.100, error=0.000
[-0.1, 0.20653640140000007, -0.23418117710000003]

Вы можете увидеть, как алгоритм очень быстро изучает проблему.

Теперь давайте применим этот алгоритм к реальному набору данных.

3. Моделирование набора данных сонара

В этом разделе мы обучим модель персептрона с использованием стохастического градиентного спуска на наборе данных сонара.

В этом примере предполагается, что CSV-копия набора данных находится в текущем рабочем каталоге с именем файла.sonar.all-data.csv,

Сначала загружается набор данных, строковые значения преобразуются в числовые, а выходной столбец преобразуется из строк в целочисленные значения от 0 до 1. Это достигается с помощью вспомогательных функций.load_csv (),str_column_to_float ()а такжеstr_column_to_int ()загрузить и подготовить набор данных.

Мы будем использовать перекрестную проверку в k-кратном размере для оценки эффективности изученной модели на невидимых данных. Это означает, что мы будем строить и оценивать k моделей и оценивать производительность как среднюю ошибку модели. Точность классификации будет использоваться для оценки каждой модели. Эти поведения представлены вcross_validation_split (),accuracy_metric ()а такжеevaluate_algorithm ()вспомогательные функции.

Мы будем использоватьпрогнозировать () иtrain_weights ()функции, созданные выше, чтобы обучить модель и новыйперсептрон ()функция, чтобы связать их вместе.

Ниже приведен полный пример.

# Perceptron Algorithm on the Sonar Dataset
from random import seed
from random import randrange
from csv import reader

# Load a CSV file
def load_csv(filename):
	dataset = list()
	with open(filename, 'r') as file:
		csv_reader = reader(file)
		for row in csv_reader:
			if not row:
				continue
			dataset.append(row)
	return dataset

# Convert string column to float
def str_column_to_float(dataset, column):
	for row in dataset:
		row[column] = float(row[column].strip())

# Convert string column to integer
def str_column_to_int(dataset, column):
	class_values = [row[column] for row in dataset]
	unique = set(class_values)
	lookup = dict()
	for i, value in enumerate(unique):
		lookup[value] = i
	for row in dataset:
		row[column] = lookup[row[column]]
	return lookup

# Split a dataset into k folds
def cross_validation_split(dataset, n_folds):
	dataset_split = list()
	dataset_copy = list(dataset)
	fold_size = int(len(dataset) / n_folds)
	for i in range(n_folds):
		fold = list()
		while len(fold) < fold_size:
			index = randrange(len(dataset_copy))
			fold.append(dataset_copy.pop(index))
		dataset_split.append(fold)
	return dataset_split

# Calculate accuracy percentage
def accuracy_metric(actual, predicted):
	correct = 0
	for i in range(len(actual)):
		if actual[i] == predicted[i]:
			correct += 1
	return correct / float(len(actual)) * 100.0

# Evaluate an algorithm using a cross validation split
def evaluate_algorithm(dataset, algorithm, n_folds, *args):
	folds = cross_validation_split(dataset, n_folds)
	scores = list()
	for fold in folds:
		train_set = list(folds)
		train_set.remove(fold)
		train_set = sum(train_set, [])
		test_set = list()
		for row in fold:
			row_copy = list(row)
			test_set.append(row_copy)
			row_copy[-1] = None
		predicted = algorithm(train_set, test_set, *args)
		actual = [row[-1] for row in fold]
		accuracy = accuracy_metric(actual, predicted)
		scores.append(accuracy)
	return scores

# Make a prediction with weights
def predict(row, weights):
	activation = weights[0]
	for i in range(len(row)-1):
		activation += weights[i + 1] * row[i]
	return 1.0 if activation >= 0.0 else 0.0

# Estimate Perceptron weights using stochastic gradient descent
def train_weights(train, l_rate, n_epoch):
	weights = [0.0 for i in range(len(train[0]))]
	for epoch in range(n_epoch):
		for row in train:
			prediction = predict(row, weights)
			error = row[-1] - prediction
			weights[0] = weights[0] + l_rate * error
			for i in range(len(row)-1):
				weights[i + 1] = weights[i + 1] + l_rate * error * row[i]
	return weights

# Perceptron Algorithm With Stochastic Gradient Descent
def perceptron(train, test, l_rate, n_epoch):
	predictions = list()
	weights = train_weights(train, l_rate, n_epoch)
	for row in test:
		prediction = predict(row, weights)
		predictions.append(prediction)
	return(predictions)

# Test the Perceptron algorithm on the sonar dataset
seed(1)
# load and prepare data
filename = 'sonar.all-data.csv'
dataset = load_csv(filename)
for i in range(len(dataset[0])-1):
	str_column_to_float(dataset, i)
# convert string class to integers
str_column_to_int(dataset, len(dataset[0])-1)
# evaluate algorithm
n_folds = 3
l_rate = 0.01
n_epoch = 500
scores = evaluate_algorithm(dataset, perceptron, n_folds, l_rate, n_epoch)
print('Scores: %s' % scores)
print('Mean Accuracy: %.3f%%' % (sum(scores)/float(len(scores))))

Значение k, равное 3, использовалось для перекрестной проверки, давая каждому сгибу 208/3 = 69,3 или чуть менее 70 записей для оценки на каждой итерации. Скорость обучения 0,1 и 500 тренировочных эпох была выбрана с небольшими экспериментами.

Вы можете попробовать свои собственные конфигурации и посмотреть, сможете ли вы побить мой счет.

Выполнение этого примера печатает оценки для каждого из 3-х сгибов перекрестной проверки, а затем печатает среднюю точность классификации.

Мы можем видеть, что точность составляет около 72%, что выше базового значения чуть более 50%, если мы только предсказывали мажоритарный класс, используя алгоритм нулевого правила.

Scores: [76.81159420289855, 69.56521739130434, 72.46376811594203]
Mean Accuracy: 72.947%

расширения

В этом разделе перечислены расширения к этому учебнику, которые вы, возможно, захотите изучить.

• Tune The Example, Настройте скорость обучения, количество эпох и даже метод подготовки данных, чтобы получить улучшенную оценку по набору данных.
• Пакетный стохастический градиентный спуск Измените алгоритм стохастического градиентного спуска, чтобы накапливать обновления для каждой эпохи и обновлять только веса в пакете в конце эпохи.
• Дополнительные проблемы регрессии, Примените метод к другим задачам классификации в хранилище машинного обучения UCI.

Вы исследовали какое-либо из этих расширений?
Дайте мне знать об этом в комментариях ниже.

Обзор

В этом руководстве вы узнали, как реализовать алгоритм Perceptron с использованием стохастического градиентного спуска с нуля с помощью Python.

Ты выучил.

• Как делать прогнозы для проблемы бинарной классификации.
• Как оптимизировать набор весов с помощью стохастического градиентного спуска.
• Как применить методику к реальной классификации задач прогнозного моделирования.

У вас есть вопросы?
Задайте свой вопрос в комментариях ниже, и я сделаю все возможное, чтобы ответить.

В этой статье мы рассмотрим персептрон Розенблатта, надеюсь, вы получите интуитивное представление о том, как работает один персептрон в целях классификации. Это считается одним из крупнейших прорывов в истории искусственного интеллекта. Лично это была первая концепция машинного обучения, которую я узнал, которая пробудила мой интерес к этой области и дала мне основу для более легкого понимания других алгоритмов машинного обучения и искусственного интеллекта.

Если вы похожи на меня в том, что лучше понимаете логические концепции, прослеживая код, а не долго читая длинные уравнения с кучей обозначений, это чтение должно быть идеальным для вас. Если у вас нет опыта работы с Python, вы все равно можете изучить концепции высокого уровня. Но в любом случае, я сделаю все возможное, чтобы объяснить, что делает каждый отдельный фрагмент кода, чтобы, если у вас нет большого опыта работы с Python, вы могли следовать за ним.

ПРИМЕЧАНИЕ: если вы хотите загрузить полный код, используемый в этой статье, вы можете найти его здесь

Абстракция высокого уровня того, что делает персептрон

Мы сосредоточимся на использовании однослойного персептрона для классификации. этот метод машинного обучения считается «обучением с учителем», поскольку мы будем снабжать алгоритм помеченными обучающими данными. Это означает, что персептрону будет предоставлен набор данных, содержащий образцы с маркировкой «n» классов для обучения.

Чтобы дать вам лучшее представление, подумайте о том, как ребенок может научиться различать собаку и кошку. Допустим, мы представляем ему 100 различных изображений кошек и собак, рассказывая ему, что представляет собой каждое из них, и он сможет различать каждое из них на основе особенностей, которые он видит. Например, он заключает, что у кошек короткие уши, а у собак длинные. Теперь, конечно, человеческий разум не смотрит на кошку и не говорит: «Если уши имеют длину от 2,345 до 3,67 см, это кошка», но именно так это может увидеть персептрон.

Если вы открывали любую другую статью или видео о персептронах до того, как попали сюда, скорее всего, вы видели эту диаграмму. Давайте сначала рассмотрим каждый компонент здесь, а затем рассмотрим сам процесс.

x и w: каждый X, представленный нижним индексом «i», здесь представляет функцию, поэтому здесь у нас есть «m» количество функций, опять же в сценарии «кошка-собака» это может быть длина уха. Каждая функция связана с весом, с математической точки зрения, вес каждой функции — это ее коэффициент. «Вес», как следует из названия, можно рассматривать как представление уровня влияния, которое оказывает эта функция. «Обучающая часть» любого алгоритма машинного обучения — это процесс нахождения оптимального значения каждого веса.

Чистый вход: чистый вход (обозначенный сигмой на диаграмме) представляет собой скалярную сумму признаков и весов:

Функция активации: это последний шаг в нашей модели классификации, функция сетевого ввода, на основе которой мы можем «классифицировать» данные с помощью двоичного вывода. Сама функция может иметь разные формы, но для простоты мы сосредоточимся на «шаговой функции», которая является самой простой реализацией; как следует из формы на диаграмме и названия, модель будет делать прогноз классификации на основе того, пересекает ли чистая входная информация определенное пороговое значение.

Ошибка: в процессе обучения модель делает прогноз, используя определенные нами компоненты, и проверяет правильность вывода. На основании ошибки мы обновляем наши веса. в конечном итоге наша цель состоит в том, чтобы свести к минимуму ошибки с каждой итерацией обучения, чтобы наша модель сходилась.

Собираем все вместе

Теперь давайте разберемся с этой моделью. Итак, мы хотим научить персептрон классифицировать два отдельных объекта с учетом ряда признаков. Алгоритм выполняет определенное количество итераций, выполняя шаги, описанные на диаграмме, обновляя веса на основе ошибки, полученной на каждой итерации.

После завершения процесса обучения у нас есть оптимизированный набор весов, который можно использовать вместе с функциями для классификации неразмеченных данных. Пока что это все очень абстрактные концепции, если вы новичок в нейронных сетях, я не ожидаю, что вы сможете смоделировать алгоритм классификатора персептрона, но важно иметь краткий обзор этих концепций, прежде чем погрузиться в алгоритмическая реализация.

Реализация бинарного классификатора персептрона в Python

Изучив концепции высокого уровня, мы можем теперь изучить детали очень простой реализации персептрона в python, чтобы закрепить наше понимание.

Прежде всего, давайте быстро пробежимся по библиотекам, которые мы будем использовать:

• Numpy: это одна из наиболее распространенных библиотек, используемых в приложениях для работы с данными. Она позволяет нам создавать «массивы numpy», похожие на списки, но их реализация позволяет нам выполнять вычисления с этими массивами.
• Случайно: мы будем использовать случайный выбор для инициализации наших весов.
• Pandas: pandas также является очень мощной библиотекой для работы с данными, но в нашем случае мы будем использовать pandas просто для импорта нашего примера набора данных.
• Matplotlib: наконец, мы будем использовать matplotlib для визуализации концепций.

Пример набора данных:

В этом примере мы будем использовать набор данных «цветок ириса». Эти данные содержат 3 разных цветка с 50 различными образцами для каждого типа цветка, содержащими 4 признака, которые численно описывают цветок (например, длину лепестка). Давайте импортируем и просмотрим этот набор данных, чтобы лучше понять, с чем мы имеем дело.

Для простоты мы будем использовать 2 из 3 цветов, поэтому наш персептрон, по сути, будет предсказывать, является ли цветок Setosa или Versicolor, основываясь на двух характеристиках (то есть ширине и длине лепестков). На графике легко заметить, что наши данные могут быть разделены линейной линией, и это то, что наша модель попытается изучить. Обратите внимание: поскольку мы сохраняем базовую модель, которую мы собираемся использовать, она сможет классифицировать только линейно разделяемые данные.

Импортировав образцы данных и библиотеки, мы можем приступить к работе с нашей моделью:

здесь мы определяем новый класс «персептрон», инициализируя скорость обучения (eta) и количество итераций (n_iter). Эти два значения называются гиперпараметрами, скорость обучения — это число с плавающей запятой от 0 до 1, а количество итераций — целое число. Оптимальное значение этих двух переменных зависит от самой проблемы. Оптимизация гиперпараметров — это тема для отдельной статьи, а пока все, что нам нужно знать об этих двух, это следующее:

• Скорость обучения (эта): интуиция здесь такова, что если скорость обучения слишком высока, наша модель выйдет за рамки допустимого.
• Количество итераций (n_iter): это количество итераций, которые наш алгоритм будет выполнять с обучающими данными.

Теперь давайте возьмем блок-схему, которую мы обсуждали ранее, и переведем ее в код Python:

В нашей модели перцептрона определены три функции. Функция fit() — это в основном место, где происходит все обучение, и веса обновляются итеративно, так что после завершения обучения у нас должен быть массив размера 3, содержащий веса для функций, и последнее значение «смещение», которое эквивалентно «у-перехвату».

Функция подгонки состоит из двух вложенных циклов. Внешний цикл — это то, сколько раз алгоритм будет работать с нашим тренировочным набором, а внутренний цикл — это фактический «обход тренировочного набора». Здесь параметр «X» представляет собой двумерный массив numpy, содержащий значения функций, а «y» — это метка для каждой строки функций. Мы используем встроенное ключевое слово python zip(X, y), чтобы в основном просмотреть каждый помеченный образец.

Наиболее неотъемлемым компонентом нашего процесса обучения является обновление веса. Обновление определяется как:

Это можно рассматривать как математическое представление того, насколько правильным или неправильным было предсказание нашей модели. Чтобы лучше понять это, мы можем рассмотреть четыре возможных результата этого уравнения. Как мы упоминали ранее, каждый цветок выражается числовым значением либо 1, либо -1, где -1 — это «сетоза», а 1 — «разноцветный».

теперь в нашем внутреннем цикле компилятор просматривает ряд образцов и пытается «предсказать», что этот образец использует с заданными функциями и текущими весами нашей модели.

Возьмем два сценария, в которых наша модель неверна (мы игнорируем eta, поскольку это просто константа):

• (1)-(-1) = 2
• (-1)-(1) = -2

Что касается того, когда наша модель правильная, мы получаем, другими словами, и метка, и прогноз имеют одинаковое значение:

• (1)-(1) = 0
• (-1)-(-1) = 0

Когда прогноз неверен, веса обновляются в направлении ошибки. Тогда как, если это правильно, результат равен нулю, а веса остаются неизменными.

Обучение нашего персептрона

надеюсь, теперь у вас есть представление о том, что делает модель, вы также можете обратиться к комментариям в коде, если что-то неясно. Итак, приступим к обучению:

сначала мы инициализируем наш персептрон как новый объект. Мы уже импортировали наш набор данных, но здесь мы определяем его в формате, который может быть понят нашей функцией fit() (принимая функции в столбцах с индексами 0 и 2 как двумерный массив numpy и 4-й index, который является классом образца в отдельном массиве numpy). Мы также используем функцию np.where, чтобы изменить строковые значения класса на 1 (лишай) и -1 (сетоза). Затем мы можем запустить функцию fit() для наших значений X и y, чтобы обучить наш персептрон, наконец, после определенного количества итераций у нас должен быть пустой массив, содержащий наш оптимальный вес, и теперь мы можем вызывать predict() на немаркированном образце, и наш персептрон классифицирует его.

Ошибки построения

Определенная переменная self.errors_ на самом деле не способствует нашему процессу обучения, но мы можем использовать ее для построения графика количества ошибок на каждой итерации:

Из графика видно, что наша модель сошлась после 6-й итерации. Это может немного меняться с каждым запуском, так как мы рандомизируем наши начальные веса.

Резюме и выводы

В этой статье мы рассмотрели абстрактные концепции очень простого персептрона, а затем подробно рассмотрели его реализацию на Python. Как я уже упоминал во введении, эта статья в основном предназначена для всех, кто знаком с python и хочет заняться машинным обучением. Исходя из моего личного опыта, я считаю, что лучше всего реализовать алгоритм с нуля, если я хочу глубже понять концепцию. Так что не стесняйтесь экспериментировать с кодом, изменяя гиперпараметры с помощью print() и графиков, чтобы лучше понять каждый компонент.

В следующей части этой статьи я подробнее остановлюсь на аспектах визуализации. Анимация процесса обучения в виде графиков, чтобы лучше понять контролируемое обучение. Имейте в виду, что это очень простая форма контролируемого машинного обучения, и, конечно же, наша модель имеет много ограничений. В будущем мы рассмотрим более сложные модели, расширяющие модель, описанную здесь.

Надеюсь, вы нашли это познавательным!

использованная литература

2015. Глава 2. Обучение простым алгоритмам машинного обучения для классификации. В С. Рашка, Машинное обучение Python (стр. 63–83). Издательство Пакет.

import numpy as np

values=([2.7810836,2.550537003],
[1.465489372,	2.362125076],
[3.396561688,	4.400293529],
[1.38807019,1.850220317],
[3.06407232,3.005305973],
[7.627531214,	2.759262235],
[5.332441248,	2.088626775],
[6.922596716,	1.77106367],
[8.675418651,	-0.242068655],
[7.673756466,	3.508563011])

print("Training input values without Biasn", values)

Training input values without Bias
 ([2.7810836, 2.550537003], [1.465489372, 2.362125076], [3.396561688, 4.400293529], [1.38807019, 1.850220317], [3.06407232, 3.005305973], [7.627531214, 2.759262235], [5.332441248, 2.088626775], [6.922596716, 1.77106367], [8.675418651, -0.242068655], [7.673756466, 3.508563011])

test2 = [[-1]] * len(values)
values = np.concatenate((test2, values), axis = 1)  
print("Training input values with bias in itn",values)

Training input values with bias in it
 [[-1.          2.7810836   2.550537  ]
 [-1.          1.46548937  2.36212508]
 [-1.          3.39656169  4.40029353]
 [-1.          1.38807019  1.85022032]
 [-1.          3.06407232  3.00530597]
 [-1.          7.62753121  2.75926224]
 [-1.          5.33244125  2.08862677]
 [-1.          6.92259672  1.77106367]
 [-1.          8.67541865 -0.24206865]
 [-1.          7.67375647  3.50856301]]

m=3     #number of elements in each row of inputs
n=1 
weights = np.random.rand(m,n)*0.1 - 0.5
print("Initial random weightsn",weights)

Initial random weights
 [[-0.45303395]
 [-0.46630376]
 [-0.47939269]]

final = ([[0],[0],[0],[0],[0],[1],[1],[1],[1],[1]])
print("Training data target values aren", final)

Training data target values are
 [[0], [0], [0], [0], [0], [1], [1], [1], [1], [1]]

def updateWeights(weights, inputs, activation, targets):
    eta = 0.25
    weights += eta*np.dot(np.transpose(inputs), targets - activation)
    return weights

def  prediction (inputs, weights, targets):
    #representing Activation function with 'ack [[]]' variable
    ack = [[0]] * len(inputs)
    for i in range(0, len(inputs)):    
        for j in range(0,len(weights)):
            ack[i] += inputs[i][j] * weights[j]
        ack[i] = np.where(ack[i]>0, 1, 0)
        #checking values with target
        if(targets[i] != ack[i]):
            weights = updateWeights(weights, inputs, ack[i], targets)
        print(ack[i])
    return weights

iterations = 4
for temp in range(0, iterations):
    print("nIteration ",temp+1,"n")
    weights = prediction(values, weights, final)
    
print("nTrained Weightsn", weights)

Iteration  1 

[0]
[0]
[0]
[0]
[0]
[0]
[1]
[1]
[1]
[1]

Iteration  2 

[1]
[1]
[0]
[0]
[0]
[1]
[1]
[1]
[1]
[1]

Iteration  3 

[0]
[0]
[0]
[0]
[0]
[1]
[1]
[1]
[1]
[1]

Iteration  4 

[0]
[0]
[0]
[0]
[0]
[1]
[1]
[1]
[1]
[1]

Trained Weights
 [[ 0.79696605]
 [ 2.54399373]
 [-5.09227188]]

def perceptronPredict(weights, newInput):
    activation = np.dot(newInput, weights)
    activation = np.where(activation>0, 1, 0)
    print(activation)


newInput = ([-1.0, 1.786745, 2.94569],
            [-1.0, 7.023323, 1.9999])
perceptronPredict(weights, newInput)

Back To Top