Многомерная линейная регрессия с нуля в Python

Многомерная линейная регрессия

Множественная линейная регрессия - это тип линейной регрессии, когда входные данные имеют несколько функций (переменных).

Представление модели

Подобно простой линейной регрессии, у нас есть входная переменная (X) и выходная переменная (Y). Но входная переменная имеет n n функций. Следовательно, мы можем представить эту линейную модель следующим образом;

Y = β0​+ β1​x1​ + β1​x2​ +…+βn​xn​

xi i-й объект во входной переменной. Введя x 0 = 1, мы можем переписать это уравнение.

Y = β0​x0​+β1​x1​+β1​x2​+…+βn​xn​

где, x 0 = 1

Теперь мы можем преобразовать это уравнение в матричную форму.

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

Градиентный спуск - это алгоритм оптимизации. Градиент означает скорость изменения или наклон кривой, здесь вы можете видеть, что изменение стоимости (J) от a до b намного выше, чем от c до d.

Наша цель с помощью этого алгоритма - найти самую низкую точку кривой или значение β 0, где Стоимость (J) самая низкая, путем постепенного спуска.

Шаг 1

Инициализируйте значения β 0, β 1,…, βn с некоторым значением. В этом случае мы инициализируемся с 0.

Шаг 2

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

• Если α очень мало, потребуется много времени, чтобы сойтись, и это станет дорогостоящим с точки зрения вычислений.
• Если α велико, он может не сойтись и выйти за минимум.

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

• Наиболее часто используемые ставки: 0,001, 0,003, 0,01, 0,03, 0,1, 0,3.

ШАГ 3

Обязательно масштабируйте объекты (X), если они очень разные. Если мы не масштабируем данные, кривые уровня (контуры) будут уже и выше, а это значит, что потребуется больше времени для схождения (см. Рисунок 3).

Масштабируйте данные так, чтобы μ = 0 и σ = 1. Ниже приведена формула масштабирования каждого примера:

ШАГ 4.

Итеративно обновить,

Это процедура. Здесь α - скорость обучения.

На шаге 4 мы изменяем значения βj в сторону уменьшения нашей функции стоимости. А Градиент задает направление, в котором мы хотим двигаться. Наконец, мы достигнем минимумов нашей функции затрат. Но мы не хотим резко менять значения βj, потому что мы можем пропустить минимумы. Вот почему нам нужна скорость обучения.

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

Мы получаем окончательную формулу для обновления нашего параметра βj и итеративного получения оптимального значения.

Алгоритм сходится, когда наклон становится равным 0, поскольку:

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

Реализация

шаг 1 :

Импорт набора данных (Электростанция комбинированного цикла):

import numpy as np
from matplotlib import pyplot as plt
import pandas as pd
%matplotlib inline
data = pd.read_excel(‘energy_data.xlsx’)
print(data.head(5))

У нас есть 4 функции (температура, вакуум, давление, влажность) и 1 целевая переменная (выход энергии). Следовательно, здесь мы должны спрогнозировать выход энергии с заданными характеристиками.

ШАГ 2:

#seperating data
X = data[:,:4]
y = data[:,-1]

Масштабируйте / стандартизируйте функции:

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

from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X = sc.fit_transform(X)

ШАГ 3.

Определение стоимости MSE:

def cost_function(X, Y, B):
 m = len(Y)
 J = np.sum((X.dot(B) — Y) ** 2)/(2 * m)
 return J

В функции пакетного градиентного спуска мы берем параметры

X: Матрица характеристик

Y: массив целевых значений

B: начальное значение тета

альфа: скорость обучения

итераций: макс. итераций алгоритма

##--------------------------------------------
def batch_gradient_descent(X, Y, B, alpha, iterations):
 cost_history = [0] * iterations
 m = len(Y)
 
 for iteration in range(iterations):
 #print(iteration)
 # Hypothesis Values
 h = X.dot(B)
 # Difference b/w Hypothesis and Actual Y
 loss = h — Y
 # Gradient Calculation
 gradient = X.T.dot(loss) / m
 # Changing Values of B using Gradient
 B = B — alpha * gradient
 # New Cost Value
 cost = cost_function(X, Y, B)
 cost_history[iteration] = cost
 
 return B, cost_history

ШАГ 4:

Разделение тренировочного и тестового наборов:

m = 7000
f = 2
X_train = X[:m,:f]
X_train = np.c_[np.ones(len(X_train),dtype=’int64'),X_train]
y_train = y[:m]
X_test = X[m:,:f]
X_test = np.c_[np.ones(len(X_test),dtype=’int64'),X_test]
y_test = y[m:]

здесь m = общее количество из выборок, которые будут включены в обучающий набор, который будет использоваться для обучения модели, оставшиеся образцы будут назначены на набор для тестирования (обучение = 7000, тестирование = 2568)

и, f = нет. функций (первые 2 функции)

ШАГ 5:

Инициализация коэффициентов (β 0, β 1,…, βn) и обучение модели

# Initial Coefficients
B = np.zeros(X_train.shape[1])
alpha = 0.005
iter_ = 2000
newB, cost_history = batch_gradient_descent(X_train, y_train, B, alpha, iter_)

здесь альфа - это скорость обучения, установленная на 0,005, а iter_ = общее количество. итераций для градиентного спуска

newB = оптимизированные коэффициенты (β 0, β 1,…, βn) после обучения модели и cost_history на итерацию

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

Оценка / тестирование модели:

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

y_ = pred(X_test,newB)

теперь проверьте, насколько хорошо он прогнозирует с использованием показателя r2:

def r2(y_,y):
 sst = np.sum((y-y.mean())**2)
 ssr = np.sum((y_-y)**2)
 r2 = 1-(ssr/sst)
 return(r2)
#----------------
r2(y_,y_test)

Результат r2 составляет 0,91404488821296… это очень хорошо!

Единичные прогнозы:

ans_ = pred(X_test[3],newB)