Курс по Нейросети. Практический курс

Текст: Введение в нейросети

Добро пожаловать в модуль «Введение в нейросети»! В этом разделе мы разберем основы нейросетей: что это такое, как они работают и где применяются.

Что такое нейросети?

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

Нейросети способны:
- Распознавать изображения и речь.
- Предсказывать результаты (например, курсы акций или погоду).
- Генерировать текст, музыку и даже изображения.

Как работают нейросети?

1. Нейроны и слои:
2. Нейросеть состоит из входного, скрытых и выходного слоев.

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

4. Обучение:

5. Нейросеть учится на примерах, корректируя веса с помощью алгоритма обратного распространения ошибки.

6. Чем больше данных, тем лучше модель предсказывает результат.

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

Пример кода (Python с библиотекой Keras)

from keras.models import Sequential
from keras.layers import Dense

# Создаем модель
model = Sequential()
model.add(Dense(units=4, activation='relu', input_dim=2))  # Скрытый слой
model.add(Dense(units=1, activation='sigmoid'))            # Выходной слой

# Компилируем модель
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Обучаем модель (X — данные, y — метки)
model.fit(X, y, epochs=10, batch_size=32)

Упражнение

Задача:
Создайте нейросеть для предсказания, является ли число четным (1) или нечетным (0).

Шаги:
1. Подготовьте данные:
- X = [[1], [2], [3], [4], ...]
- y = [0, 1, 0, 1, ...]
2. Используйте код выше, заменив input_dim=1 (так как вход — одно число).
3. Обучите модель и проверьте ее на числах 5, 10, 17.

Ожидаемый результат:
Модель должна предсказать:
- 5 → 0 (нечетное)
- 10 → 1 (четное)
- 17 → 0 (нечетное)

Заключение

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

Готовы к практике? Переходите к следующему разделу! 🚀

Текст: "Как устроена нейросеть"

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

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

• Нейроны (узлы) — базовые единицы, которые обрабатывают информацию. Каждый нейрон получает входные данные, выполняет вычисления и передает результат дальше.
• Слои — группы нейронов, объединенных по функциональности:
• Входной слой — получает исходные данные (например, пиксели изображения).
• Скрытые слои — промежуточные слои, где происходят основные вычисления. Чем их больше, тем "глубже" сеть (отсюда термин глубокое обучение).
• Выходной слой — возвращает итоговый результат (например, класс объекта или текст).
• Веса и смещения — параметры, которые нейросеть "учится" настраивать. Веса определяют силу связи между нейронами, а смещения помогают точнее настраивать выход.
• Функция активации — добавляет нелинейность, позволяя сети обучаться сложным закономерностям. Примеры: ReLU, сигмоида, гиперболический тангенс.

2. Как нейросеть принимает решения?

Процесс называется прямым распространением (forward propagation):
1. Данные поступают на входной слой.
2. Каждый нейрон скрытых слоев умножает входы на веса, суммирует их, добавляет смещение и применяет функцию активации.
3. Результат передается дальше, пока не достигнет выходного слоя.

Пример:
Допустим, нейросеть определяет, есть ли на изображении кошка. Входные данные — пиксели, выход — вероятность (от 0 до 1). Если выход > 0.5, сеть "решает", что кошка есть.

3. Как нейросеть обучается?

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

Упражнение 1: "Визуализация простой нейросети"

Задача: Нарисуйте схему нейросети с:
- 3 нейронами во входном слое (например, для признаков: длина, ширина, цвет),
- 2 скрытыми слоями по 4 нейрона,
- 1 выходным нейроном (например, "класс объекта").
Подпишите слои и связи между ними.

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

Входной слой → Скрытый слой 1 → Скрытый слой 2 → Выходной слой  

Упражнение 2: "Рассчет выхода нейрона"

Задача: Пусть нейрон имеет:
- Входы: ( x_1 = 0.5 ), ( x_2 = 0.3 )
- Веса: ( w_1 = 1.2 ), ( w_2 = -0.4 )
- Смещение: ( b = 0.1 )
- Функция активации: ReLU (( f(x) = \max(0, x) )).

Вычислите выход нейрона.

Решение:
1. Сумма: ( z = x_1 \cdot w_1 + x_2 \cdot w_2 + b = 0.5 \cdot 1.2 + 0.3 \cdot (-0.4) + 0.1 = 0.6 - 0.12 + 0.1 = 0.58 ).
2. Применяем ReLU: ( \max(0, 0.58) = 0.58 ).

Ответ: 0.58.

Пример из жизни: "Нейросеть для распознавания цифр"

Представьте нейросеть, которая определяет рукописные цифры (как в почтовых индексах). Вход — изображение 28x28 пикселей (784 входных нейрона), выход — 10 нейронов (цифры 0-9). Сеть обучается на тысячах примеров, корректируя веса так, чтобы правильно классифицировать цифры.

Итог:

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

Вопрос для размышления: Как вы думаете, почему в глубоких сетях часто используют функцию ReLU вместо сигмоиды? (Подсказка: подумайте о скорости обучения и проблеме "исчезающих градиентов").

Пример работы простой нейросети

Цель: Наглядно продемонстрировать, как простая нейросеть принимает решение на основе входных данных.

Сценарий: Нейросеть для предсказания цены квартиры

Представим, что мы создаем нейросеть, которая предсказывает стоимость квартиры на основе двух параметров:
- Площадь (м²)
- Количество комнат

Архитектура нейросети:
- Входной слой: 2 нейрона (площадь и количество комнат).
- Скрытый слой: 3 нейрона с функцией активации ReLU.
- Выходной слой: 1 нейрон (предсказанная цена).

Код на Python (с использованием библиотеки Keras):

import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

# Данные для обучения: [площадь, комнаты], цена
X_train = np.array([[50, 1], [70, 2], [90, 3], [110, 4]])  # Входные данные
y_train = np.array([3.5, 5.0, 6.5, 8.0])  # Цены в млн руб.

# Создаем модель
model = Sequential([
    Dense(3, activation='relu', input_shape=(2,)),  # Скрытый слой
    Dense(1)  # Выходной слой
])

# Компилируем модель
model.compile(optimizer='adam', loss='mse')

# Обучаем нейросеть
model.fit(X_train, y_train, epochs=100, verbose=0)

# Предсказываем цену для новой квартиры
new_apartment = np.array([[65, 2]])  # 65 м², 2 комнаты
predicted_price = model.predict(new_apartment)
print(f"Предсказанная цена: {predicted_price[0][0]:.2f} млн руб.")

Ожидаемый результат:
Нейросеть выдаст примерную стоимость квартиры, например:

Предсказанная цена: 4.75 млн руб.

Разбор примера:

1. Данные: Нейросеть обучается на исторических данных (площадь, комнаты → цена).
2. Обучение: Модель корректирует веса, чтобы минимизировать ошибку (MSE — среднеквадратичная ошибка).
3. Предсказание: После обучения нейросеть может оценить стоимость новой квартиры.

Практическое задание:
1. Измените входные данные (например, добавьте квартиру 80 м² с 3 комнатами за 7 млн).
2. Запустите код снова и сравните предсказание.
3. Попробуйте добавить больше скрытых слоев. Как это повлияет на результат?

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

Текст: Обучение нейросетей

Что такое обучение нейросети?
Обучение нейросети — это процесс, при котором модель настраивает свои внутренние параметры (веса и смещения) так, чтобы минимизировать ошибку предсказаний на обучающих данных. Проще говоря, нейросеть "учится" на примерах, постепенно улучшая свою точность.

Как происходит обучение?
1. Подача данных: Нейросети передаются входные данные (например, изображения или числа) и правильные ответы (если обучение с учителем).
2. Прямое распространение (Forward Propagation): Данные проходят через слои нейросети, и на выходе получается предсказание.
3. Расчёт ошибки: Сравнивается предсказание с правильным ответом с помощью функции потерь (например, среднеквадратичной ошибки).
4. Обратное распространение ошибки (Backpropagation): Алгоритм вычисляет, как каждый параметр сети влияет на ошибку, и корректирует веса с помощью градиентного спуска.
5. Обновление весов: Веса изменяются так, чтобы в следующий раз ошибка была меньше.

Типы обучения:
- С учителем (Supervised Learning): Нейросеть обучается на размеченных данных (например, фотографиях с подписями).
- Без учителя (Unsupervised Learning): Нейросеть ищет закономерности в данных без готовых ответов (например, кластеризация).
- С подкреплением (Reinforcement Learning): Нейросеть учится на основе обратной связи от среды (как в играх или робототехнике).

Пример кода (обучение простой нейросети на Python с библиотекой Keras):

from keras.models import Sequential
from keras.layers import Dense

# Создаём модель
model = Sequential()
model.add(Dense(units=64, activation='relu', input_dim=100))  # Входной слой
model.add(Dense(units=10, activation='softmax'))  # Выходной слой

# Компилируем модель
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

# Обучаем модель на данных (X_train — входные данные, y_train — правильные ответы)
model.fit(X_train, y_train, epochs=10, batch_size=32)

Упражнение:
1. Задача: Попробуйте обучить простую нейросеть для распознавания рукописных цифр (датасет MNIST).
2. Инструкции:
- Загрузите датасет MNIST с помощью keras.datasets.mnist.
- Нормализуйте данные (делите на 255).
- Создайте модель с одним скрытым слоем (128 нейронов, активация relu) и выходным слоем (10 нейронов, активация softmax).
- Обучите модель на 10 эпохах и проверьте точность на тестовых данных.
3. Ожидаемый результат: После обучения модель должна достичь точности выше 95% на тестовой выборке.

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

Практическое задание: создание мини-нейросети

Тип: Упражнение

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

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

Необходимые знания:
- Базовое понимание Python.
- Знакомство с библиотеками NumPy и Matplotlib (желательно, но не обязательно).

Инструкции:

Шаг 1: Подготовка данных

1. Создайте простой набор данных для обучения. Например:
2. Входные данные (X): [1, 2, 3, 4, 5]
3. Выходные данные (y): [2, 4, 6, 8, 10] (здесь y = 2 * X).

Шаг 2: Инициализация параметров нейросети

1. Нейрон имеет два параметра:
2. Вес (weight), например, начальное значение 0.5.
3. Смещение (bias), например, начальное значение 0.

Шаг 3: Реализация функции предсказания (прямой проход)

1. Нейросеть делает предсказание по формуле:
   python def predict(X, weight, bias): return X * weight + bias

Шаг 4: Расчет ошибки (функция потерь)

1. Используйте среднеквадратичную ошибку (MSE):
   python def mse_loss(y_true, y_pred): return ((y_true - y_pred) ** 2).mean()

Шаг 5: Обучение нейросети (градиентный спуск)

1. Обновите вес и смещение, используя простой градиентный спуск:
   ```python learning_rate = 0.01 epochs = 100 # Количество итераций обучения

for epoch in range(epochs): # Предсказание y_pred = predict(X, weight, bias)

   # Расчет градиентов
   d_weight = -2 * (X * (y - y_pred)).mean()
   d_bias = -2 * (y - y_pred).mean()

   # Обновление параметров
   weight -= learning_rate * d_weight
   bias -= learning_rate * d_bias

   # Вывод ошибки (опционально)
   if epoch % 10 == 0:
       print(f"Epoch {epoch}, Loss: {mse_loss(y, y_pred)}")

```

Шаг 6: Проверка работы нейросети

1. После обучения проверьте предсказания на новых данных, например:
   python test_X = 10 predicted_y = predict(test_X, weight, bias) print(f"Для X = {test_X}, предсказание: {predicted_y}") # Ожидается ~20

Ожидаемый результат:

После выполнения кода нейросеть должна научиться предсказывать значения, близкие к y = 2 * X. Например, для X = 10 вывод должен быть около 20.

Дополнительное задание:
- Попробуйте изменить начальные weight и bias. Как это влияет на обучение?
- Добавьте больше данных в обучающую выборку. Улучшается ли точность?
- Визуализируйте процесс обучения с помощью Matplotlib (постройте график изменения ошибки).

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