Реализуйте функцию mserror среднеквадратичную ошибку прогноза

Всем привет!
Прохожу на Курсере *Обучение на размеченных данных*. Сейчас начинаю уже последнюю 5ю неделю, почти всё понятно, всё решаю.
Кроме 1й недели! Она так и осталась несданной, а сроки поджимают.
Там в первом и втором задании ошибиться невозможно, кода на 3 строчки. Но мой ответ почти в 20 раз больше требуемого!!!

Вот первое задание:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# импорт модулей
import pandas as pd
import numpy as np
 
# Взяли данные
adver_data = pd.read_csv('advertising.csv')  
 
# Разбили на 2 выборки
X = adver_data[['TV', 'Radio', 'Newspaper']].values 
y = adver_data[['Sales']].values 
 
# Отмасштабируйте столбцы матрицы X, вычтя из каждого значения среднее по соответствующему столбцу
#  и поделив результат на стандартное отклонение. 
means, stds = np.mean(X, axis=0), np.std(X, axis=0) 
X = (X - means)/stds
 
# Добавьте к матрице X столбец из единиц
X = np.hstack([X, np.ones((X.shape[0], 1))]) 
 
#  -----Задание-----
# 2. Реализуйте функцию mserror - среднеквадратичную ошибку прогноза.
#  Она принимает два аргумента - объекты Series y (значения целевого признака) и y_pred (предсказанные значения). 
# Не используйте в этой функции циклы - тогда она будет вычислительно неэффективной.
def mserr(y, y_pred):
return np.mean((y - y_pred) ** 2)  
answer1 = np.mean((y - np.median(y))**2)

Ответ будет 495.0152, хотя должен быть 28.ххххх — РАСХОЖДЕНИЕ АДОВО!
Пробовал использовать ‘родную’ функцию sklearn.metrics.mean_squared_error — результат ровно такой же 495.0152, т.е. неверный.
Похожая картина во втором задании — вроде бы всё несложно, но ответ совершенно другой!
Все остальные задания в этой неделе основаны на пунктах 1и 2.

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

2. # coding: utf-8

4. # # Линейная регрессия и стохастический градиентный спуск

6. # Задание основано на материалах лекций по линейной регрессии и градиентному спуску. Вы будете прогнозировать выручку компании в зависимости от уровня ее инвестиций в рекламу по TV, в газетах и по радио.

8. # ## Вы научитесь:

9. # — решать задачу восстановления линейной регрессии

10. # — реализовывать стохастический градиентный спуск для ее настройки

11. # — решать задачу линейной регрессии аналитически

13. # ## Введение

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

16. # Линейная регрессия использует простой функционал качества — среднеквадратичную ошибку. Мы будем работать с выборкой, содержащей 3 признака. Для настройки параметров (весов) модели решается следующая задача:

17. # $$frac{1}{ell}sum_{i=1}^ell{{(y_i — (w_0 + w_1x_{i1} + w_2x_{i2} +  w_3x_{i3}))}^2} rightarrow min_{w_0, w_1, w_2, w_3},$$

18. # где $x_{i1}, x_{i2}, x_{i3}$ — значения признаков $i$-го объекта, $y_i$ — значение целевого признака $i$-го объекта, $ell$ — число объектов в обучающей выборке.

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

21. # Параметры $w_0, w_1, w_2, w_3$, по которым минимизируется среднеквадратичная ошибка, можно находить численно с помощью градиентного спуска.

22. # Градиентный шаг для весов будет выглядеть следующим образом:

23. # $$w_0 leftarrow w_0 + frac{2eta}{ell} sum_{i=1}^ell{{(y_i — (w_0 + w_1x_{i1} + w_2x_{i2} +  w_3x_{i3}))}}$$

24. # $$w_j leftarrow w_j + frac{2eta}{ell} sum_{i=1}^ell{{x_{ij}(y_i — (w_0 + w_1x_{i1} + w_2x_{i2} +  w_3x_{i3}))}}, j in {1,2,3}$$

25. # Здесь $eta$ — параметр, шаг градиентного спуска.

27. # ## Стохастический градиентный спуск

28. # У градиентного спуска, описанного выше, есть один недостаток. На больших выборках вычисление градиента по всем имеющимся данным на каждом шаге может быть вычислительно сложно.

29. # В стохастическом варианте градиентного спуска поправки для весов вычисляются только с учетом одного случайно взятого объекта обучающей выборки:

30. # $$w_0 leftarrow w_0 + frac{2eta}{ell} {(y_k — (w_0 + w_1x_{k1} + w_2x_{k2} +  w_3x_{k3}))}$$

31. # $$w_j leftarrow w_j + frac{2eta}{ell} {x_{kj}(y_k — (w_0 + w_1x_{k1} + w_2x_{k2} +  w_3x_{k3}))}, j in {1,2,3},$$

32. # где $k$ — случайный индекс, $k in {1, ldots, ell}$.

34. # ## Нормальное уравнение

35. # Нахождение вектора оптимальных весов $w$ может быть сделано и аналитически.

36. # Мы хотим найти такой вектор весов $w$, чтобы вектор $y$, соответствующий целевому признаку, получался умножением матрицы $X$ (состоящей из всех признаков объектов обучающей выборки, кроме целевого) на вектор весов $w$. То есть, чтобы выполнялось матричное уравнение:

37. # $$y = Xw$$

38. # Домножением слева на $X^T$ получаем:

39. # $$X^Ty = X^TXw$$

40. # Это хорошо, поскольку теперь матрица $X^TX$ — квадратная, и можно найти решение (вектор $w$) в виде:

41. # $$w = {(X^TX)}^{-1}X^Ty$$

42. # Матрица ${(X^TX)}^{-1}X^T$ — [*псевдообратная*](https://ru.wikipedia.org/wiki/Псевдообратная_матрица) для матрицы $X$. В NumPy такую матрицу можно вычислить с помощью функции [numpy.linalg.pinv](http://docs.scipy.org/doc/numpy-1.10.0/reference/generated/numpy.linalg.pinv.html).

43. #

44. # Однако, нахождение псевдообратной матрицы — операция вычислительно сложная и нестабильная в случае малого определителя матрицы $X$ (проблема мультиколлинеарности).

45. # На практике лучше находить вектор весов $w$ решением матричного уравнения

46. # $$X^TXw = X^Ty$$Это может быть сделано с помощью функции [numpy.linalg.solve](http://docs.scipy.org/doc/numpy-1.10.1/reference/generated/numpy.linalg.solve.html).

47. #

48. # Но все же на практике для больших матриц $X$ быстрее работает градиентный спуск, особенно его стохастическая версия.

50. # ## Инструкции по выполнению

52. # В начале напишем простую функцию для записи ответов в текстовый файл. Ответами будут числа, полученные в ходе решения этого задания, округленные до 3 знаков после запятой. Полученные файлы после выполнения задания надо отправить в форму на странице задания на Coursera.org.

54. # In[1]:

56. def write_answer_to_file(answer, filename):

57. with open(filename, ‘w’) as f_out:

58.         f_out.write(str(round(answer, 3)))

61. # **1. Загрузите данные из файла *advertising.csv* в объект pandas DataFrame. [Источник данных](http://www-bcf.usc.edu/~gareth/ISL/data.html).**

63. # In[2]:

65. import pandas as pd

66. adver_data = pd.read_csv(‘advertising.csv’)

69. # **Посмотрите на первые 5 записей и на статистику признаков в этом наборе данных.**

71. # In[3]:

73. adver_data.head(n=5)

76. # In[4]:

78. adver_data.describe()

81. # **Создайте массивы NumPy *X* из столбцов TV, Radio и Newspaper и *y* — из столбца Sales. Используйте атрибут *values* объекта pandas DataFrame.**

83. # In[5]:

85. X = adver_data[[«TV»,«Radio», «Newspaper»]].values

86. Y = adver_data[[«Sales»]].values

89. # **Отмасштабируйте столбцы матрицы *X*, вычтя из каждого значения среднее по соответствующему столбцу и поделив результат на стандартное отклонение.**

91. # In[6]:

93. import numpy as np

94. means, stds = np.mean(X, axis=0), np.std(X, axis=0)

97. # In[7]:

99. X = (X — means)/stds

102. # **Добавьте к матрице *X* столбец из единиц, используя методы *hstack*, *ones* и *reshape* библиотеки NumPy. Вектор из единиц нужен для того, чтобы не обрабатывать отдельно коэффициент $w_0$ линейной регрессии.**

104. # In[8]:

106. import numpy as np

107. X = np.hstack([X, np.ones((X.shape[0],1))])

110. # **2. Реализуйте функцию *mserror* — среднеквадратичную ошибку прогноза. Она принимает два аргумента — объекты Series *y* (значения целевого признака) и *y_pred* (предсказанные значения).**

112. # In[9]:

114. def mserror(y, y_pred):

115. return round((sum((y — y_pred)**2)[0])/float(y.shape[0]), 3)

118. # **Какова среднеквадратичная ошибка прогноза значений Sales, если всегда предсказывать медианное значение Sales по исходной выборке? Запишите ответ в файл ‘1.txt’.**

120. # In[10]:

122. eye = np.array([np.median(Y)]*Y.shape[0]).reshape((Y.shape[0], 1))

123. answer1 = mserror(Y, eye)

124. print(answer1)

125. write_answer_to_file(answer1, ‘1.txt’)

128. # **3. Реализуйте функцию *normal_equation*, которая по заданным матрицам (массивам NumPy) *X* и *y* вычисляет вектор весов $w$ согласно нормальному уравнению линейной регрессии.**

130. # In[11]:

132. def normal_equation(X, y):

133. return np.dot(np.dot(np.linalg.pinv(np.dot(X.T, X)), X.T), y)

136. # In[12]:

138. norm_eq_weights = normal_equation(X, Y)

139. print(norm_eq_weights)

142. # **Какие продажи предсказываются линейной моделью с весами, найденными с помощью нормального уравнения, в случае средних инвестиций в рекламу по ТВ, радио и в газетах? (то есть при нулевых значениях масштабированных признаков TV, Radio и Newspaper). Запишите ответ в файл ‘2.txt’.**

144. # In[13]:

146. answer2 = np.dot(np.mean(X, axis=0), norm_eq_weights)[0]

147. print(answer2)

148. write_answer_to_file(answer2, ‘2.txt’)

151. # **4. Напишите функцию *linear_prediction*, которая принимает на вход матрицу *X* и вектор весов линейной модели *w*, а возвращает вектор прогнозов в виде линейной комбинации столбцов матрицы *X* с весами *w*.**

153. # In[14]:

155. def linear_prediction(X, w):

156. return np.dot(X, w)

159. # **Какова среднеквадратичная ошибка прогноза значений Sales в виде линейной модели с весами, найденными с помощью нормального уравнения? Запишите ответ в файл ‘3.txt’.**

161. # In[15]:

163. answer3 = mserror(Y, linear_prediction(X, norm_eq_weights))

164. print(answer3)

165. write_answer_to_file(answer3, ‘3.txt’)

168. # **5. Напишите функцию *stochastic_gradient_step*, реализующую шаг стохастического градиентного спуска для линейной регрессии. Функция должна принимать матрицу *X*, вектора *y* и *w*, число *train_ind* — индекс объекта обучающей выборки (строки матрицы *X*), по которому считается изменение весов, а также число *$eta$* (eta) — шаг градиентного спуска (по умолчанию *eta*=0.01). Результатом будет вектор обновленных весов.**

170. # In[16]:

172. def stochastic_gradient_step(X, y, w, train_ind, eta=0.01):

173.     x_k = X[train_ind, :]

174.     y_k = y[train_ind]

175.     y_pred = np.dot(x_k, w)

176.     l = X.shape[0]

177. return w + (2*eta/l)*(y_k — y_pred)*x_k

180. # **6. Напишите функцию *stochastic_gradient_descent*, реализующую стохастический градиентный спуск для линейной регрессии. Функция принимает на вход следующие аргументы:**

181. # — X — матрица, соответствующая обучающей выборке

182. # — y — вектор значений целевого признака

183. # — w_init — вектор начальных весов модели

184. # — eta — шаг градиентного спуска (по умолчанию 0.01)

185. # — max_iter — максимальное число итераций градиентного спуска (по умолчанию 10000)

186. # — max_weight_dist — минимальное евклидово расстояние между векторами весов на соседних итерациях градиентного спуска,

187. # при котором алгоритм прекращает работу (по умолчанию 1e-8)

188. # — seed — число, используемое для воспроизводимости сгенерированных псевдослучайных чисел (по умолчанию 42)

189. # — verbose — флаг печати информации (например, для отладки, по умолчанию False)

190. #

191. # **На каждой итерации в вектор (список) должно записываться текущее значение среднеквадратичной ошибки. Функция должна возвращать вектор весов $w$, а также вектор (список) ошибок.**

193. # In[40]:

195. def stochastic_gradient_descent(X, y, w_init, eta=1e-2, max_iter=1e4,

196.                                 min_weight_dist=1e-8, seed=42, verbose=False):

197. # Инициализируем расстояние между векторами весов на соседних

198. # итерациях большим числом.

199.     weight_dist = np.inf

200. # Инициализируем вектор весов

201.     w = w_init

202. # Сюда будем записывать ошибки на каждой итерации

203.     errors = []

204. # Счетчик итераций

205.     iter_num = 0

206. # Будем порождать псевдослучайные числа

207. # (номер объекта, который будет менять веса), а для воспроизводимости

208. # этой последовательности псевдослучайных чисел используем seed.

209.     np.random.seed(seed)

211. # Основной цикл

212. while weight_dist > min_weight_dist and iter_num < max_iter:

213. # порождаем псевдослучайный

214. # индекс объекта обучающей выборки

215.         random_ind = np.random.randint(X.shape[0])

217. # Ваш код здесь

218.         old_w = w

219.         w = stochastic_gradient_step(X, y, w, random_ind, eta=eta)

220.         weight_dist = np.linalg.norm(w — old_w)

221.         errors.append(mserror(y, np.dot(X, w)))

222.         iter_num += 1

224. if iter_num % 10000 == 0 and verbose:

225. print «Iteration: «, iter_num

227. return w, errors

230. #  **Запустите $10^5$ итераций стохастического градиентного спуска. Укажите вектор начальных весов *w_init*, состоящий из нулей. Оставьте параметры  *eta* и *seed* равными их значениям по умолчанию (*eta*=0.01, *seed*=42 — это важно для проверки ответов).**

232. # In[41]:

234. get_ipython().run_cell_magic(u‘time’, u», u‘stoch_grad_desc_weights, stoch_errors_by_iter = stochastic_gradient_descent(X, Y, np.ones((X.shape[1])), eta=1e-2, max_iter=10**5, verbose = True)’)

237. # In[42]:

239. get_ipython().magic(u‘pylab inline’)

240. plot(range(len(stoch_errors_by_iter)), stoch_errors_by_iter)

241. xlabel(‘Iteration number’)

242. ylabel(‘MSE’)

245. # **Посмотрим на вектор весов, к которому сошелся метод.**

247. # In[43]:

249. stoch_grad_desc_weights

252. # **Посмотрим на среднеквадратичную ошибку на последней итерации.**

254. # In[44]:

256. stoch_errors_by_iter[—1]

259. # **Какова среднеквадратичная ошибка прогноза значений Sales в виде линейной модели с весами, найденными с помощью градиентного спуска? Запишите ответ в файл ‘4.txt’.**

261. # In[61]:

263. print sum((Y — np.dot(X, stoch_grad_desc_weights).reshape((Y.shape[0], 1)))**2)/float(Y.shape[0])

264. answer4 = round(np.mean((Y — np.dot(X, stoch_grad_desc_weights).reshape((Y.shape[0], 1)))**2), 3)

265. print(answer4)

266. write_answer_to_file(answer4, ‘4.txt’)

269. # **Ответами к заданию будут текстовые файлы, полученные в ходе этого решения. Обратите внимание, что отправленные файлы не должны содержать пустую строку в конце. Данный нюанс является ограничением платформы Coursera. Мы работаем над исправлением этого ограничения.**

Время на прочтение
4 мин

Количество просмотров 4.3K

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

Существует несколько способов вычислить эту разницу. В этом материале мы рассмотрим некоторые из наиболее распространенных функций потерь.

Ниже будут рассмотрены следующие четыре функции потерь.

• Среднеквадратическая ошибка

• Среднеквадратическая ошибка

• Средняя абсолютная ошибка

• Кросс-энтропийные потери

Из этих четырех функций потерь первые три применяются к модели классификации.

1. Среднеквадратическая ошибка (MSE)

Среднеквадратичная ошибка (MSE) рассчитывается как среднее значение квадратов разностей между прогнозируемыми и фактически наблюдаемыми значениями. Математически это можно выразить следующим образом:

Реализация MSE на языке Python выглядит следующим образом:

import numpy as np # импортируем библиотеку numpy
def mean_squared_error(act, pred): # функция 

   diff = pred - act # находим разницу между прогнозируемыми и наблюдаемыми значениями
   differences_squared = diff ** 2 # возводим в квадрат (чтобы избавиться от отрицательных значений)
   mean_diff = differences_squared.mean() # находим среднее значение
   
   return mean_diff

act = np.array([1.1,2,1.7]) # создаем список актуальных значений
pred = np.array([1,1.7,1.5]) # список прогнозируемых значений

print(mean_squared_error(act,pred)) 

Выход :

0.04666666666666667

Вы также можете использовать mean_squared_error из sklearn для расчета MSE. Вот как работает функция:

from sklearn.metrics import mean_squared_error
act = np.array([1.1,2,1.7])
pred = np.array([1,1.7,1.5])
mean_squared_error(act, pred)

Выход :

0.04666666666666667

2. Корень среднеквадратической ошибки (RMSE)

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

Корень среднеквадратической ошибки (RMSE) мы используем для того чтобы избавиться от квадратной степени, в которую мы ранее возвели действительную ошибку среди между прогнозируемыми и фактически наблюдаемыми значениями. Математически мы можем представить это следующим образом:

Реализация Python для RMSE выглядит следующим образом:

import numpy as np
def root_mean_squared_error(act, pred):

   diff = pred - act # находим разницу между прогнозируемыми и наблюдаемыми значениями
   differences_squared = diff ** 2 # возводим в квадрат
   mean_diff = differences_squared.mean() # находим среднее значение
   rmse_val = np.sqrt(mean_diff) # извлекаем квадратный корень
   return rmse_val

act = np.array([1.1,2,1.7])
pred = np.array([1,1.7,1.5])

print(root_mean_squared_error(act,pred))

Выход :

0.21602468994692867

Вы также можете использовать mean_squared_error из sklearn для расчета RMSE. Давайте посмотрим, как реализовать RMSE, используя ту же функцию:

from sklearn.metrics import mean_squared_error
act = np.array([1.1,2,1.7])
pred = np.array([1,1.7,1.5])
mean_squared_error(act, pred, squared = False) #Если установлено значение False, функция возвращает значение RMSE.

Выход :

0.21602468994692867

Если для параметра squared установлено значение True, функция возвращает значение MSE. Если установлено значение False, функция возвращает значение RMSE.

3. Средняя абсолютная ошибка (MAE)

Средняя абсолютная ошибка (MAE) рассчитывается как среднее значение абсолютной разницы между прогнозами и фактическими наблюдениями. Математически мы можем представить это следующим образом:

Реализация Python для MAE выглядит следующим образом:

import numpy as np 
def mean_absolute_error(act, pred): #
    diff = pred - act # находим разницу между прогнозируемыми и наблюдаемыми значениями
    abs_diff = np.absolute(diff) # находим абсолютную разность между прогнозами и фактическими наблюдениями.
    mean_diff = abs_diff.mean() # находим среднее значение
    return mean_diff

act = np.array([1.1,2,1.7])
pred = np.array([1,1.7,1.5])
mean_absolute_error(act,pred)

Выход :

0.20000000000000004

Вы также можете использовать mean_absolute_error из sklearn для расчета MAE.

from sklearn.metrics import mean_absolute_error
act = np.array([1.1,2,1.7])
pred = np.array([1,1.7,1.5])
mean_absolute_error(act, pred)

Выход :

0.20000000000000004

4. Функция потерь перекрестной энтропии в Python

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

Давайте посмотрим, как вычислить ошибку в случае проблемы бинарной классификации.

Давайте рассмотрим проблему классификации, когда модель пытается провести классификацию между собакой и кошкой.

Код Python для поиска ошибки приведен ниже.

from sklearn.metrics import log_loss
log_loss(["Dog", "Cat", "Cat", "Dog"],[[.1, .9], [.9, .1], [.8, .2], [.35, .65]])

Выход :

0.21616187468057912

Мы используем метод log_loss из sklearn.

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

Вероятности представлены в следующем формате:

[P(dog), P(cat)]

Заключение

Это руководство было посвящено функциям потерь в Python. Мы рассмотрели различные функции потерь как для задач регрессии, так и для задач классификации. Надеюсь, вам понравился материал, ведь все было достаточно легко и понятно!

Кстати, для тех, кто хотел бы пойти дальше в изучении функций потерь, мы предлагаем разобрать одну вот такую — это очень интересная функция потерь Triplet Loss в Python (функцию тройных потерь), которую для вас любезно подготовил автор.