Дайте мне знать, если вы найдете это ценным, и я продолжу!

Глава 1. Линейная модель

Одной из самых простых, но мощных концепций является линейная модель.

В машинном обучении одна из наших основных целей — делать прогнозы на основе данных. Линейная модель похожа на «Привет, мир» машинного обучения: она проста, но формирует основу для понимания более сложных моделей.

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

def prediction(sqft, num_bedrooms, num_baths):
    weight_1, weight_2, weight_3 = .0, .0, .0  
    home_price = weight_1*sqft, weight_2*num_bedrooms, weight_3*num_baths
    return home_price

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

Итак, давайте выясним, как найти эти веса.

Нахождение весов

Процесс определения весов называется «обучением» модели.

• Во-первых, нам нужен набор данных домов с известными характеристиками (входные данные) и ценами (выходные данные). Например:

data = [
    {"sqft": 1000, "bedrooms": 2, "baths": 1, "price": 200000},
    {"sqft": 1500, "bedrooms": 3, "baths": 2, "price": 300000},
    # ... more data points ...
]

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

home_price = prediction(1000, 2, 1) # our weights are currently zero, so this is zero
actual_value = 200000

error = home_price - actual_value # 0 - 200000 we are way off. 
# let's square this value so we aren't dealing with negatives
error = home_price**2

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

• Наконец, обновите веса таким образом, чтобы уменьшить среднеквадратическую ошибку.

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

Градиентный спуск

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

Градиент — это вектор, который сообщает нам, как меняется ошибка при небольших изменениях каждого веса.

Интуиция боковой панели
Представьте, что вы стоите на холмистой местности и ваша цель — достичь самой низкой точки (минимальная ошибка). Градиент подобен компасу, который всегда указывает на самый крутой подъем. Двигаясь против направления градиента, мы приближаемся к самой низкой точке.

Вот как это работает:

1. Начните со случайных весов (или нулей).
2. Вычислить погрешность для текущих весов.
3. Вычислите градиент (наклон) ошибки для каждого веса.
4. Обновите веса, переместив небольшой шаг в сторону уменьшения ошибки.
5. Повторяйте шаги 2–4, пока ошибка не перестанет значительно уменьшаться.

Как рассчитать градиент для каждой ошибки?

Один из способов расчета градиента — внести небольшие изменения в вес, посмотреть, как это повлияет на нашу ошибку, и посмотреть, куда нам следует двигаться дальше.

def calculate_gradient(weight, data, feature_index, step_size=1e-5):
    original_error = calculate_mean_squared_error(weight, data)

    # Slightly increase the weight
    weight[feature_index]  = step_size
    new_error = calculate_mean_squared_error(weight, data)

    # Calculate the slope
    gradient = (new_error - original_error) / step_size

    # Reset the weight
    weight[feature_index] -= step_size

    return gradient

Пошаговое описание

• Входные параметры:

  • вес: текущий набор весов для нашей модели.
  • данные: наш набор данных о характеристиках домов и ценах.
  • Feature_index: вес, для которого мы рассчитываем градиент (0 для квадратных футов, 1 для спален, 2 для ванн).
  • Step_size: небольшое значение, которое мы используем для небольшого изменения веса (по умолчанию — 1e-5 или 0,00001).

• Вычислить исходную ошибку:
  
  

   original_error = calculate_mean_squared_error(weight, data)

Сначала мы вычисляем среднеквадратическую ошибку с нашими текущими весами. Это дает нам отправную точку.

• Слегка увеличить вес:

   weight[feature_index]  = step_size

Мы немного увеличиваем вес (step_size). Это позволяет нам увидеть, как небольшое изменение веса влияет на нашу ошибку.

• Вычислить новую ошибку:

   new_error = calculate_mean_squared_error(weight, data)

Мы снова вычисляем среднеквадратическую ошибку со слегка увеличенным весом.

• Рассчитать наклон (градиент):

   gradient = (new_error - original_error) / step_size

Это ключевой шаг. Спрашиваем: «Насколько изменилась ошибка, когда мы немного увеличили вес?»

• Если new_error > original_error, градиент положителен, то есть увеличение этого веса увеличивает ошибку.
• Если new_error

• Амплитуда показывает, насколько чувствительна ошибка к изменениям этого веса.

  • Сбросить вес:

   weight[feature_index] -= step_size

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

• Вернуть градиент:

   return gradient

Мы возвращаем рассчитанный градиент для этого веса.

Это называется «числовым расчетом градиента» или «методом конечных разностей». Мы аппроксимируем градиент, а не вычисляем его аналитически.

Давайте обновим веса

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

weights[i] -= gradients[i]

Если наш градиент слишком велик, мы можем легко превысить минимальный уровень, слишком сильно обновив вес. Чтобы это исправить, мы можем умножить градиент на небольшое число:

learning_rate = 0.00001
weights[i] -= learning_rate*gradients[i]

И вот как мы это делаем для всех весов:

def gradient_descent(data, learning_rate=0.00001, num_iterations=1000):
    weights = [0, 0, 0]  # Start with zero weights

    for _ in range(num_iterations):
        gradients = [
            calculate_gradient(weights, data, 0), # sqft
            calculate_gradient(weights, data, 1), # bedrooms
            calculate_gradient(weights, data, 2)  # bathrooms
        ]

        # Update each weight
        for i in range(3):
            weights[i] -= learning_rate * gradients[i]

        if _ % 100 == 0:
            error = calculate_mean_squared_error(weights, data)
            print(f"Iteration {_}, Error: {error}, Weights: {weights}")

    return weights

Наконец-то у нас есть гири!

Интерпретация модели

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

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

Например, если наши обученные веса равны [100, 10000, 15000], это означает:

• Каждый квадратный фут добавляет к цене дома 100 долларов.
• Каждая спальня добавляет к цене дома 10 000 долларов.
• Каждая ванная добавляет к цене дома 15 000 долларов.

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