Лаб. работа “Создание и обучение простейших нейронных сетей”

Разработка и оптимизация интеллектуальных информационных систем
Практика
Автор

Бизюк Андрей

Дата публикации

21 октября 2025 г.

Лабораторная работа: Создание и обучение простейших нейронных сетей

Цель работы

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

Краткие теоретические сведения

Что такое нейронная сеть?

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

Основные компоненты нейронной сети:

  1. Нейрон (персептрон): Базовый элемент сети, принимающий входные сигналы, обрабатывающий их и выдающий выходной сигнал.
  2. Веса (weights): Коэффициенты, определяющие силу связи между нейронами.
  3. Смещение (bias): Дополнительный параметр, позволяющий сдвигать активационную функцию.
  4. Активационная функция: Функция, определяющая выходной сигнал нейрона на основе взвешенной суммы входов. Примеры: ReLU, Sigmoid, Tanh.
  5. Слои (layers): Группы нейронов, объединенные по определенному принципу. Основные типы:
    • Входной слой (input layer): Получает входные данные.
    • Скрытые слои (hidden layers): Производят промежуточные вычисления.
    • Выходной слой (output layer): Выдает конечный результат.

Процесс обучения:

  1. Прямое распространение (forward propagation): Входные данные проходят через сеть, и вычисляется выход.
  2. Вычисление ошибки (loss/cost function): Сравнивается полученный выход с истинным значением.
  3. Обратное распространение ошибки (backpropagation): Ошибка распространяется назад по сети, и вычисляются градиенты.
  4. Обновление весов (weight update): Веса корректируются с помощью алгоритма оптимизации (например, градиентного спуска).

Библиотеки Python для работы с нейронными сетями:

  • TensorFlow/Keras: Мощные библиотеки для создания и обучения глубоких нейронных сетей.
  • PyTorch: Альтернатива TensorFlow, популярна в научных исследованиях.
  • Scikit-learn: Содержит реализации простых нейронных сетей (MLPClassifier, MLPRegressor) и удобные инструменты для предобработки данных.

Порядок выполнения работы

Работа выполняется в среде Python с использованием библиотек numpy, scikit-learn, matplotlib/seaborn.

  1. Подготовка окружения. Установите необходимые библиотеки, если они отсутствуют:

    pip install numpy scikit-learn matplotlib seaborn

  2. Создание простого персептрона. Реализуем базовый нейрон с двумя входами, который будет решать простую задачу логического “И” (AND).

    import numpy as np

# Определим активационную функцию (ступенчатая)
def step_function(x):
    return 1 if x >= 0 else 0

# Класс простого персептрона
class Perceptron:
    def __init__(self, num_inputs, learning_rate=0.1):
        # Инициализируем веса случайными значениями
        self.weights = np.random.rand(num_inputs)
        self.bias = np.random.rand(1)[0]
        self.learning_rate = learning_rate

    def predict(self, inputs):
        # Вычисляем взвешенную сумму
        summation = np.dot(inputs, self.weights) + self.bias
        # Применяем активационную функцию
        return step_function(summation)

    def train(self, training_inputs, labels, epochs):
        # Обучение персептрона
        for _ in range(epochs):
            for inputs, label in zip(training_inputs, labels):
                prediction = self.predict(inputs)
                # Обновляем веса и смещение
                self.weights += self.learning_rate * (label - prediction) * inputs
                self.bias += self.learning_rate * (label - prediction)

# Данные для задачи AND
training_inputs = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
labels = np.array([0, 0, 0, 1])  # Результаты операции AND

# Создаем и обучаем персептрон
perceptron = Perceptron(2)
print("Начальные веса:", perceptron.weights)
print("Начальное смещение:", perceptron.bias)

perceptron.train(training_inputs, labels, epochs=10)

print("Обученные веса:", perceptron.weights)
print("Обученное смещение:", perceptron.bias)

# Тестируем персептрон
print("\nРезультаты предсказаний:")
for inputs in training_inputs:
    print(f"{inputs} -> {perceptron.predict(inputs)}")

  3. Создание многослойного персептрона (MLP) с помощью Scikit-learn. Решим задачу классификации на датасете Iris.

    from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.metrics import accuracy_score, classification_report
import pandas as pd

# Загружаем датасет
iris = load_iris()
X = iris.data  # Признаки
y = iris.target  # Целевая переменная

# Разделяем данные на обучающую и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Создаем MLP классификатор
# hidden_layer_sizes=(10,) означает один скрытый слой с 10 нейронами
mlp = MLPClassifier(hidden_layer_sizes=(10,), max_iter=1000, random_state=42)

# Обучаем модель
mlp.fit(X_train, y_train)

# Делаем предсказания
y_pred = mlp.predict(X_test)

# Оцениваем качество
accuracy = accuracy_score(y_test, y_pred)
print(f"Точность модели: {accuracy:.2f}")
print("\nПодробный отчет:")
print(classification_report(y_test, y_pred, target_names=iris.target_names))

  4. Визуализация процесса обучения. Построим график изменения функции потерь во время обучения.

    import matplotlib.pyplot as plt

# Создаем модель с возможностью отслеживания потерь
mlp_viz = MLPClassifier(hidden_layer_sizes=(10,), max_iter=500, random_state=42, solver='sgd', 
                        learning_rate_init=0.01, verbose=True)

# Обучаем модель
mlp_viz.fit(X_train, y_train)

# Получаем значения потерь на каждой итерации
loss_values = mlp_viz.loss_curve_

# Строим график
plt.figure(figsize=(10, 6))
plt.plot(loss_values)
plt.title('Изменение функции потерь во время обучения')
plt.xlabel('Итерации')
plt.ylabel('Значение функции потерь')
plt.grid(True)
plt.show()

  5. Эксперименты с архитектурой сети. Попробуем изменить количество скрытых слоев и нейронов в них.

    # Создаем несколько моделей с разной архитектурой
models = {
    '1 слой (5 нейронов)': MLPClassifier(hidden_layer_sizes=(5,), max_iter=1000, random_state=42),
    '1 слой (20 нейронов)': MLPClassifier(hidden_layer_sizes=(20,), max_iter=1000, random_state=42),
    '2 слоя (10, 5)': MLPClassifier(hidden_layer_sizes=(10, 5), max_iter=1000, random_state=42),
    '3 слоя (15, 10, 5)': MLPClassifier(hidden_layer_sizes=(15, 10, 5), max_iter=1000, random_state=42)
}

results = {}

# Обучаем каждую модель и оцениваем точность
for name, model in models.items():
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)
    accuracy = accuracy_score(y_test, y_pred)
    results[name] = accuracy
    print(f"{name}: Точность = {accuracy:.2f}")

# Визуализируем результаты
plt.figure(figsize=(10, 6))
names = list(results.keys())
accuracies = list(results.values())
bars = plt.bar(names, accuracies, color=['blue', 'green', 'red', 'orange'])
plt.ylim(0.8, 1.0)
plt.ylabel('Точность')
plt.title('Сравнение точности моделей с разной архитектурой')
plt.xticks(rotation=45)

# Добавляем значения на столбцы
for bar, acc in zip(bars, accuracies):
    plt.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.005, f'{acc:.2f}', 
             ha='center', va='bottom')

plt.tight_layout()
plt.show()

Задания для самостоятельной работы

Задание 1

  1. Повторить все шаги, описанные в разделе “Порядок выполнения работы”.
  2. В отчете подробно описать каждый шаг, приложить фрагменты кода и результаты его выполнения.
  3. В заключении ответить на вопрос: почему персептрон не может решить задачу “Исключающее ИЛИ” (XOR)?

Задание 2

  1. Загрузить датасет “Wine” из sklearn.datasets.
  2. Создать и обучить MLPClassifier с одной скрытым слоем из 15 нейронов.
  3. Оценить точность модели на тестовой выборке.
  4. Попробовать разные функции активации (relu, tanh, logistic) и сравнить результаты.
  5. В заключении проанализировать, как выбор функции активации влияет на качество модели.

Задание 3

  1. Загрузить датасет “Breast Cancer Wisconsin” из sklearn.datasets.
  2. Создать и обучить несколько моделей MLPClassifier с разными параметрами:
    • Разное количество скрытых слоев и нейронов.
    • Разные значения параметра alpha (L2 регуляризация).
  3. Сравнить точность моделей.
  4. В заключении оценить, какие параметры оказали наибольшее влияние на качество классификации.

Требования к отчету

Отчет по лабораторной работе должен содержать:

  1. Цель работы.

  2. Постановка задачи в соответствии с вариантом.

  3. Ход работы: последовательное описание выполненных шагов с приведением ключевых фрагментов кода, скриншотов и/или таблиц с результатами.

  4. Графики и их анализ (например, изменение функции потерь, сравнение точности моделей).

  5. Выводы по работе, включающие ответы на вопросы из задания по варианту и общую оценку проделанной работы.

Контрольные вопросы

  1. Что такое искусственный нейрон? Опишите его основные компоненты.
  2. В чем разница между прямым распространением и обратным распространением?
  3. Какие функции активации вы знаете? В каких случаях их лучше использовать?
  4. Что такое переобучение (overfitting)? Как с ним бороться?
  5. Какие преимущества и недостатки имеют многослойные персептроны по сравнению с другими алгоритмами машинного обучения?
Наверх