История и развития ИИ. Персептрон.ipynb

В июле 1958 года, в присутствии прессы, в IBM 704 (5-тонный компьютер размером с комнату) была загружена серия перфокарт. После 50 циклов обучения компьютер научился отличать два типа карт друг от друга.

Это была демонстрация "персептрона" - "первой машины, способной иметь собственные мысли", как ее охарактеризовал ее создатель Фрэнк Розенблатт.

Персептрон от итальянского perceptio - восприимчивый

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

«Истории о создании машин, обладающих человеческими качествами, уже давно стали увлекательной областью научной фантастики», — писал Розенблатт в 1958 году. «И все же мы вот-вот станем свидетелями рождения такой машины – машины, способной воспринимать, распознавать и идентифицировать свое окружение без какого-либо человеческого обучения или контроля».

Он был прав, но чтобы доказать это, потребовалось полвека.

Фрэнк Розенблатт (слева) и Чарльз В. Вайтман работают над частью устройства, которое в декабре 1958 года стало первым персептроном.

Розенблатт родился в 1928 году и вырос в Нью-Рошель, пригороде Нью-Йорка. Он учился в Высшей научной школе Бронкса. В Корнелле он специализировался на социальной психологии и получил степень доктора философии в психологии (в российской классификации - кандидат психологических наук 5.3).

Это исследование привело его к вычислительной технике. Будучи докторантом, он построил «Компьютер для анализа электронного профиля». На нем он проводил анализ личностных данных для своей диссертации. Позже Розенблат стал разрабатывать перцептрон. Целью ученого было разгадать тайны мозга.

«Он хотел выяснить: какое минимальное количество нейронов физически должен иметь мозг, чтобы совершать те удивительные вещи, которые он делает?» Ричард О'Брайен, бывший директор Отделения биологических наук Корнеллского университета, на поминальной службе Розенблатта.

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

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

Он становится более точным после тысяч или миллионов итераций.

Второй тип (версия) персептрона должен был назваться— Тобермори. В честь говорящего кота из рассказа Г. Х. Манро.

image.png

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

«У Розенблатта была идея, что он сможет заставить компьютеры видеть и понимать язык, критики утверждали, что этого не произойдет, потому что функции персептронов слишком примитивны». На самом деле, проблема заключалась в том, что перцептрон Розенблатта имел только один слой, а современные нейронные сети — миллионы.

«Розенблатт хотел показать машине объекты и заставить ее распознавать эти объекты. И 60 лет спустя мы наконец-то смогли это сделать. Значит, он шел по правильному пути. В то время наука не знала, как обучать многоуровневые сети. Но, оглядываясь назад, можно сказать, что его алгоритм по-прежнему имеет фундаментальное значение для того, как мы сегодня обучаем глубокие сети». В 1969 году Мински и Сеймур Паперт опубликовали «Персептроны», книгу, которая подвергла критике работу Розенблатта и, по сути, решила ее судьбу. В следующем году Мински получил Премию Тьюринга – высшую награду в области компьютерных технологий.

Розенблатт не пережил зиму искусственного интеллекта. В 1971 году он утонул во время плавания на шлюпе «Шеруотер» в Чесапикском заливе в свой 43-й день рождения.

Резюме по теории персептрона:

Персептрон - это простая модель искусственного нейрона, разработанная Френком Розенблаттом в 1957 году. Он является основой для более сложных нейронных сетей и впервые представил идею обучения с учителем.

Структура персептрона: Персептрон состоит из входных узлов (input nodes), каждый из которых связан с весом (weight), а также имеет смещение (bias). Входные данные подаются на входные узлы, затем их умножают на соответствующие веса, суммируют и добавляют смещение. Полученная сумма проходит через функцию активации, и результат выходит из персептрона.

Функция активации: Функция активации принимает сумму взвешенных входов и возвращает результат, который определяет активацию нейрона. Наиболее распространенные функции активации в персептронах:

1. Step Function: Простая функция, которая возвращает 1, если вход больше или равен нулю, и 0 в противном случае.
2. Sigmoid Function: Гладкая функция, которая принимает любое вещественное число и возвращает значение в интервале (0, 1). Это позволяет интерпретировать результат как вероятность.
3. ReLU (Rectified Linear Unit): Функция, которая возвращает входное значение, если оно положительное, иначе возвращает ноль. Она часто используется в современных нейронных сетях из-за своей простоты и эффективности.

Обучение персептрона: Основная идея обучения персептрона заключается в настройке его весов таким образом, чтобы минимизировать ошибку между прогнозируемыми и фактическими значениями. Это обычно делается путем итеративного процесса, называемого градиентным спуском (gradient descent). На каждой итерации градиентного спуска веса обновляются в направлении, противоположном градиенту функции потерь.

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

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

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

Математически, для одного нейрона в персептроне, выход у нейрона при активации ϕ с входом x и весами w (включая биас b) может быть вычислен как:

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

Давайте программно создадим персептрон, который будет выполнять логическую операцию ИЛИ

#Можете предложить свой вариант кода для решения данной задачи

Посмотрите пример:

# @title Посмотрите пример:
import torch

# Функция активации (ступенчатая)
def activation_function(x):
    return torch.tensor(1.0) if x >= 0 else torch.tensor(0.0)

# Класс персептрона
class Perceptron:
    def __init__(self, num_inputs):
        # Инициализация весов случайными значениями
        self.weights = torch.rand(num_inputs, dtype=torch.float64)
        self.bias = torch.rand(1, dtype=torch.float64)  # Инициализация смещения случайным значением

    # Функция, вычисляющая выход персептрона
    def feed_forward(self, inputs):
        return activation_function(torch.sum(inputs * self.weights) + self.bias)

    # Функция обучения персептрона
    def train(self, inputs, target, learning_rate=0.1):
        output = self.feed_forward(inputs)
        error = target - output

        # Обновление весов и смещения
        self.weights += error * inputs * learning_rate
        self.bias += error * learning_rate

# Основная функция
if __name__ == "__main__":
    # Создание персептрона с двумя входами
    perceptron = Perceptron(2)

    # Обучающие данные
    training_inputs = torch.tensor([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=torch.float64)
    training_outputs = torch.tensor([0, 1, 1, 1], dtype=torch.float64)  # Логическая операция ИЛИ

    # Обучение персептрона
    for _ in range(10):
        for inputs, target in zip(training_inputs, training_outputs):
            perceptron.train(inputs, target)

    # Проверка обученного персептрона
    for inputs, target in zip(training_inputs, training_outputs):
        output = perceptron.feed_forward(inputs)
        print(f"Входы: {inputs.tolist()} Выход: {int(output)}")

Входы: [0.0, 0.0] Выход: 0
Входы: [0.0, 1.0] Выход: 1
Входы: [1.0, 0.0] Выход: 1
Входы: [1.0, 1.0] Выход: 1

import torch

# Функция активации (ступенчатая)
def activation_function(x):
    return 1 if x >= 0 else 0

# Класс персептрона
class Perceptron:
    def __init__(self, num_inputs):
        # Инициализация весов случайными значениями
        self.weights = torch.rand(num_inputs, dtype=torch.float64)
        self.bias = torch.rand(1, dtype=torch.float64)  # Инициализация смещения случайным значением

    # Функция, вычисляющая выход персептрона
    def feed_forward(self, inputs):
        return activation_function(torch.sum(inputs * self.weights) + self.bias)

    # Функция обучения персептрона
    def train(self, inputs, target, learning_rate=0.1):
        output = self.feed_forward(inputs)
        error = target - output

        # Вывод входов, выходов и ошибки
        print(f"Входы: {inputs.tolist()} Выход: {int(output)} Ошибка: {error}")

        # Обновление весов и смещения
        self.weights += error * inputs * learning_rate
        self.bias += error * learning_rate

# Основная функция
if __name__ == "__main__":
    # Создание персептрона с двумя входами
    perceptron = Perceptron(2)

    # Обучающие данные
    training_inputs = torch.tensor([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=torch.float64)
    training_outputs = torch.tensor([0, 1, 1, 1], dtype=torch.float64)  # Логическая операция ИЛИ

    # Обучение персептрона
    for _ in range(10):
        for inputs, target in zip(training_inputs, training_outputs):
            perceptron.train(inputs, target)

    # Проверка обученного персептрона
    for inputs, target in zip(training_inputs, training_outputs):
        output = perceptron.feed_forward(inputs)
        print(f"Входы: {inputs.tolist()} Выход: {int(output)}")

Входы: [0.0, 0.0] Выход: 1 Ошибка: -1.0
Входы: [0.0, 1.0] Выход: 1 Ошибка: 0.0
Входы: [1.0, 0.0] Выход: 1 Ошибка: 0.0
Входы: [1.0, 1.0] Выход: 1 Ошибка: 0.0
Входы: [0.0, 0.0] Выход: 0 Ошибка: 0.0
Входы: [0.0, 1.0] Выход: 1 Ошибка: 0.0
Входы: [1.0, 0.0] Выход: 1 Ошибка: 0.0
Входы: [1.0, 1.0] Выход: 1 Ошибка: 0.0
Входы: [0.0, 0.0] Выход: 0 Ошибка: 0.0
Входы: [0.0, 1.0] Выход: 1 Ошибка: 0.0
Входы: [1.0, 0.0] Выход: 1 Ошибка: 0.0
Входы: [1.0, 1.0] Выход: 1 Ошибка: 0.0
Входы: [0.0, 0.0] Выход: 0 Ошибка: 0.0
Входы: [0.0, 1.0] Выход: 1 Ошибка: 0.0
Входы: [1.0, 0.0] Выход: 1 Ошибка: 0.0
Входы: [1.0, 1.0] Выход: 1 Ошибка: 0.0
Входы: [0.0, 0.0] Выход: 0 Ошибка: 0.0
Входы: [0.0, 1.0] Выход: 1 Ошибка: 0.0
Входы: [1.0, 0.0] Выход: 1 Ошибка: 0.0
Входы: [1.0, 1.0] Выход: 1 Ошибка: 0.0
Входы: [0.0, 0.0] Выход: 0 Ошибка: 0.0
Входы: [0.0, 1.0] Выход: 1 Ошибка: 0.0
Входы: [1.0, 0.0] Выход: 1 Ошибка: 0.0
Входы: [1.0, 1.0] Выход: 1 Ошибка: 0.0
Входы: [0.0, 0.0] Выход: 0 Ошибка: 0.0
Входы: [0.0, 1.0] Выход: 1 Ошибка: 0.0
Входы: [1.0, 0.0] Выход: 1 Ошибка: 0.0
Входы: [1.0, 1.0] Выход: 1 Ошибка: 0.0
Входы: [0.0, 0.0] Выход: 0 Ошибка: 0.0
Входы: [0.0, 1.0] Выход: 1 Ошибка: 0.0
Входы: [1.0, 0.0] Выход: 1 Ошибка: 0.0
Входы: [1.0, 1.0] Выход: 1 Ошибка: 0.0
Входы: [0.0, 0.0] Выход: 0 Ошибка: 0.0
Входы: [0.0, 1.0] Выход: 1 Ошибка: 0.0
Входы: [1.0, 0.0] Выход: 1 Ошибка: 0.0
Входы: [1.0, 1.0] Выход: 1 Ошибка: 0.0
Входы: [0.0, 0.0] Выход: 0 Ошибка: 0.0
Входы: [0.0, 1.0] Выход: 1 Ошибка: 0.0
Входы: [1.0, 0.0] Выход: 1 Ошибка: 0.0
Входы: [1.0, 1.0] Выход: 1 Ошибка: 0.0
Входы: [0.0, 0.0] Выход: 0
Входы: [0.0, 1.0] Выход: 1
Входы: [1.0, 0.0] Выход: 1
Входы: [1.0, 1.0] Выход: 1

Упражнения

1. Обучите персептрон:

   

   #Можете предложить свой вариант кода для решения данной задачи

2. Обучите персептрон:

   

   #Можете предложить свой вариант кода для решения данной задачи

3. Какие еще логические функции вам известны? Обучите им персептрон

   #Можете предложить свой вариант кода для решения данной задачи

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

Основные шаги, которые нужно выполнить в коде:

1. Определение функции активации - ступенчатой функции округления.
2. Определение класса Perceptron, который представляет собой персептрон с настраиваемым количеством входов.
   • Инициализация весов и смещения случайными значениями.
   • Реализация функции прямого распространения (feed_forward) и функции обучения (train).
3. В основной части кода:
   • Создание экземпляра персептрона с 3 входами.
   • Генерация последовательности из 25 случайных двоичных чисел.
   • Обучение персептрона на скользящих окнах по 3 числа из последовательности.
   • Вычисление средней ошибки обучения.
   • Проверка обученного персептрона на оставшихся числах последовательности.
   • Вычисление средней ошибки проверки.

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

#Можете предложить свой вариант кода для решения данной задачи

Пример кода

#@title Пример кода
# pip install torch

import torch

# Функция активации (ступенчатая)
def activation_function(x):
    return torch.round(x)

# Класс персептрона
class Perceptron:
    def __init__(self, num_inputs):
        # Инициализация весов случайными значениями
        self.weights = torch.rand(num_inputs, dtype=torch.float64)
        self.bias = torch.rand(1, dtype=torch.float64)  # Инициализация смещения случайным значением

    # Функция, вычисляющая выход персептрона
    def feed_forward(self, inputs):
        return activation_function(torch.sum(inputs * self.weights) + self.bias)

    # Функция обучения персептрона
    def train(self, inputs, target, learning_rate=0.1):
        output = self.feed_forward(inputs)
        error = target - output

        # Вывод входов, выходов и ошибки
        print(f"Входы: {inputs.tolist()} | Выход: {int(output)} | Ошибка: {int(error)}")

        # Обновление весов и смещения
        self.weights += error * inputs * learning_rate
        self.bias += error * learning_rate

# Основная функция
if __name__ == "__main__":
    # Создание персептрона с тремя входами
    perceptron = Perceptron(3)

    # Генерация последовательности из 25 целых десятичных чисел от 0 до 1
    sequence = [torch.randint(0, 2, (1,), dtype=torch.float64) for _ in range(25)]

    # Вывод сгенерированной последовательности
    print("Сгенерированная последовательность:")
    for i, item in enumerate(sequence):
        print(f"Число {i+1}: {int(item.item())}")

    # Обучение персептрона для каждых трех чисел в последовательности
    total_error = 0
    for i in range(3, len(sequence)):
        input_data = torch.tensor([sequence[i-3].item(), sequence[i-2].item(), sequence[i-1].item()])
        target = sequence[i].item()
        perceptron.train(input_data, target)
        total_error += abs(target - perceptron.feed_forward(input_data))

    average_train_error = total_error / (len(sequence) - 3)
    print(f"Средняя ошибка обучения: {average_train_error.item():.2f}")


    # Проверка обученного персептрона
    print("Проверка обученного персептрона:")
    total_error = 0
    for i in range(3, len(sequence)):
        input_data = torch.tensor([sequence[i-3].item(), sequence[i-2].item(), sequence[i-1].item()])
        target = sequence[i].item()
        output = perceptron.feed_forward(input_data)
        error = abs(target - output)
        total_error += error
        print(f"Входы: {input_data.tolist()} | Ожидаемый вывод: {int(target)} | Предсказанный вывод: {int(output)} | Ошибка: {int(error)}")

    average_test_error = total_error / (len(sequence) - 3)
    print(f"Средняя ошибка обучения: {average_test_error.item():.2f}")

Результат:

Сгенерированная последовательность:
Число 1: 1
Число 2: 0
Число 3: 0
Число 4: 0
Число 5: 1
Число 6: 0
Число 7: 0
Число 8: 0
Число 9: 0
Число 10: 0
Число 11: 0
Число 12: 0
Число 13: 0
Число 14: 1
Число 15: 0
Число 16: 1
Число 17: 0
Число 18: 1
Число 19: 1
Число 20: 1
Число 21: 0
Число 22: 0
Число 23: 0
Число 24: 1
Число 25: 1
Входы: [1.0, 0.0, 0.0] | Выход: 1 | Ошибка: -1
Входы: [0.0, 0.0, 0.0] | Выход: 1 | Ошибка: 0
Входы: [0.0, 0.0, 1.0] | Выход: 1 | Ошибка: -1
Входы: [0.0, 1.0, 0.0] | Выход: 1 | Ошибка: -1
Входы: [1.0, 0.0, 0.0] | Выход: 0 | Ошибка: 0
Входы: [0.0, 0.0, 0.0] | Выход: 0 | Ошибка: 0
Входы: [0.0, 0.0, 0.0] | Выход: 0 | Ошибка: 0
Входы: [0.0, 0.0, 0.0] | Выход: 0 | Ошибка: 0
Входы: [0.0, 0.0, 0.0] | Выход: 0 | Ошибка: 0
Входы: [0.0, 0.0, 0.0] | Выход: 0 | Ошибка: 0
Входы: [0.0, 0.0, 0.0] | Выход: 0 | Ошибка: 1
Входы: [0.0, 0.0, 1.0] | Выход: 1 | Ошибка: -1
Входы: [0.0, 1.0, 0.0] | Выход: 0 | Ошибка: 1
Входы: [1.0, 0.0, 1.0] | Выход: 1 | Ошибка: -1
Входы: [0.0, 1.0, 0.0] | Выход: 1 | Ошибка: 0
Входы: [1.0, 0.0, 1.0] | Выход: 0 | Ошибка: 1
Входы: [0.0, 1.0, 1.0] | Выход: 1 | Ошибка: 0
Входы: [1.0, 1.0, 1.0] | Выход: 1 | Ошибка: -1
Входы: [1.0, 1.0, 0.0] | Выход: 0 | Ошибка: 0
Входы: [1.0, 0.0, 0.0] | Выход: 0 | Ошибка: 0
Входы: [0.0, 0.0, 0.0] | Выход: 0 | Ошибка: 1
Входы: [0.0, 0.0, 1.0] | Выход: 1 | Ошибка: 0
Средняя ошибка обучения: 0.14
Проверка обученного персептрона:
Входы: [1.0, 0.0, 0.0] | Ожидаемый вывод: 0 | Предсказанный вывод: 0 | Ошибка: 0
Входы: [0.0, 0.0, 0.0] | Ожидаемый вывод: 1 | Предсказанный вывод: 1 | Ошибка: 0
Входы: [0.0, 0.0, 1.0] | Ожидаемый вывод: 0 | Предсказанный вывод: 1 | Ошибка: 1
Входы: [0.0, 1.0, 0.0] | Ожидаемый вывод: 0 | Предсказанный вывод: 1 | Ошибка: 1
Входы: [1.0, 0.0, 0.0] | Ожидаемый вывод: 0 | Предсказанный вывод: 0 | Ошибка: 0
Входы: [0.0, 0.0, 0.0] | Ожидаемый вывод: 0 | Предсказанный вывод: 1 | Ошибка: 1
Входы: [0.0, 0.0, 0.0] | Ожидаемый вывод: 0 | Предсказанный вывод: 1 | Ошибка: 1
Входы: [0.0, 0.0, 0.0] | Ожидаемый вывод: 0 | Предсказанный вывод: 1 | Ошибка: 1
Входы: [0.0, 0.0, 0.0] | Ожидаемый вывод: 0 | Предсказанный вывод: 1 | Ошибка: 1
Входы: [0.0, 0.0, 0.0] | Ожидаемый вывод: 0 | Предсказанный вывод: 1 | Ошибка: 1
Входы: [0.0, 0.0, 0.0] | Ожидаемый вывод: 1 | Предсказанный вывод: 1 | Ошибка: 0
Входы: [0.0, 0.0, 1.0] | Ожидаемый вывод: 0 | Предсказанный вывод: 1 | Ошибка: 1
Входы: [0.0, 1.0, 0.0] | Ожидаемый вывод: 1 | Предсказанный вывод: 1 | Ошибка: 0
Входы: [1.0, 0.0, 1.0] | Ожидаемый вывод: 0 | Предсказанный вывод: 0 | Ошибка: 0
Входы: [0.0, 1.0, 0.0] | Ожидаемый вывод: 1 | Предсказанный вывод: 1 | Ошибка: 0
Входы: [1.0, 0.0, 1.0] | Ожидаемый вывод: 1 | Предсказанный вывод: 0 | Ошибка: 1
Входы: [0.0, 1.0, 1.0] | Ожидаемый вывод: 1 | Предсказанный вывод: 1 | Ошибка: 0
Входы: [1.0, 1.0, 1.0] | Ожидаемый вывод: 0 | Предсказанный вывод: 0 | Ошибка: 0
Входы: [1.0, 1.0, 0.0] | Ожидаемый вывод: 0 | Предсказанный вывод: 0 | Ошибка: 0
Входы: [1.0, 0.0, 0.0] | Ожидаемый вывод: 0 | Предсказанный вывод: 0 | Ошибка: 0
Входы: [0.0, 0.0, 0.0] | Ожидаемый вывод: 1 | Предсказанный вывод: 1 | Ошибка: 0
Входы: [0.0, 0.0, 1.0] | Ожидаемый вывод: 1 | Предсказанный вывод: 1 | Ошибка: 0
Средняя ошибка обучения: 0.41

import torch

# Функция активации (ступенчатая)
def activation_function(x):
    return 1 if x >= 0 else 0

# Класс персептрона
class Perceptron:
    def __init__(self, num_inputs):
        # Инициализация весов случайными значениями
        self.weights = torch.rand(num_inputs, dtype=torch.float64)
        self.bias = torch.rand(1, dtype=torch.float64)  # Инициализация смещения случайным значением

    # Функция, вычисляющая выход персептрона
    def feed_forward(self, inputs):
        return activation_function(torch.sum(inputs * self.weights) + self.bias)

    # Функция обучения персептрона
    def train(self, inputs, target, learning_rate=0.1):
        output = self.feed_forward(inputs)
        error = target - output

        # Вывод входов, выходов и ошибки
        print(f"Входы: {inputs.tolist()} Выход: {int(output)} Ошибка: {error}")

        # Обновление весов и смещения
        self.weights += error * inputs * learning_rate
        self.bias += error * learning_rate

# Основная функция
if __name__ == "__main__":
    # Создание персептрона с двумя входами
    perceptron = Perceptron(2)

    # Обучающие данные
    training_inputs = torch.tensor([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=torch.float64)
    training_outputs = torch.tensor([0, 0, 0, 1], dtype=torch.float64)  # Логическая операция И

    # Обучение персептрона
    for _ in range(10):
        for inputs, target in zip(training_inputs, training_outputs):
            perceptron.train(inputs, target)

    # Проверка обученного персептрона
    for inputs, target in zip(training_inputs, training_outputs):
        output = perceptron.feed_forward(inputs)
        print(f"Входы: {inputs.tolist()} Выход: {int(output)}")

Результат:

Входы: [0.0, 0.0] Выход: 1 Ошибка: -1.0
Входы: [0.0, 1.0] Выход: 1 Ошибка: -1.0
Входы: [1.0, 0.0] Выход: 1 Ошибка: -1.0
Входы: [1.0, 1.0] Выход: 1 Ошибка: 0.0
Входы: [0.0, 0.0] Выход: 1 Ошибка: -1.0
Входы: [0.0, 1.0] Выход: 1 Ошибка: -1.0
Входы: [1.0, 0.0] Выход: 1 Ошибка: -1.0
Входы: [1.0, 1.0] Выход: 1 Ошибка: 0.0
Входы: [0.0, 0.0] Выход: 1 Ошибка: -1.0
Входы: [0.0, 1.0] Выход: 0 Ошибка: 0.0
Входы: [1.0, 0.0] Выход: 1 Ошибка: -1.0
Входы: [1.0, 1.0] Выход: 1 Ошибка: 0.0
Входы: [0.0, 0.0] Выход: 0 Ошибка: 0.0
Входы: [0.0, 1.0] Выход: 0 Ошибка: 0.0
Входы: [1.0, 0.0] Выход: 1 Ошибка: -1.0
Входы: [1.0, 1.0] Выход: 1 Ошибка: 0.0
Входы: [0.0, 0.0] Выход: 0 Ошибка: 0.0
Входы: [0.0, 1.0] Выход: 0 Ошибка: 0.0
Входы: [1.0, 0.0] Выход: 1 Ошибка: -1.0
Входы: [1.0, 1.0] Выход: 0 Ошибка: 1.0
Входы: [0.0, 0.0] Выход: 0 Ошибка: 0.0
Входы: [0.0, 1.0] Выход: 0 Ошибка: 0.0
Входы: [1.0, 0.0] Выход: 1 Ошибка: -1.0
Входы: [1.0, 1.0] Выход: 0 Ошибка: 1.0
Входы: [0.0, 0.0] Выход: 0 Ошибка: 0.0
Входы: [0.0, 1.0] Выход: 0 Ошибка: 0.0
Входы: [1.0, 0.0] Выход: 1 Ошибка: -1.0
Входы: [1.0, 1.0] Выход: 1 Ошибка: 0.0
Входы: [0.0, 0.0] Выход: 0 Ошибка: 0.0
Входы: [0.0, 1.0] Выход: 0 Ошибка: 0.0
Входы: [1.0, 0.0] Выход: 0 Ошибка: 0.0
Входы: [1.0, 1.0] Выход: 1 Ошибка: 0.0
Входы: [0.0, 0.0] Выход: 0 Ошибка: 0.0
Входы: [0.0, 1.0] Выход: 0 Ошибка: 0.0
Входы: [1.0, 0.0] Выход: 0 Ошибка: 0.0
Входы: [1.0, 1.0] Выход: 1 Ошибка: 0.0
Входы: [0.0, 0.0] Выход: 0 Ошибка: 0.0
Входы: [0.0, 1.0] Выход: 0 Ошибка: 0.0
Входы: [1.0, 0.0] Выход: 0 Ошибка: 0.0
Входы: [1.0, 1.0] Выход: 1 Ошибка: 0.0
Входы: [0.0, 0.0] Выход: 0
Входы: [0.0, 1.0] Выход: 0
Входы: [1.0, 0.0] Выход: 0
Входы: [1.0, 1.0] Выход: 1