Градиентный спуск – это первый алгоритм оптимизации порядка, чтобы найти минимум функции. Он находит минимум (локальный) функции, двигаясь по направлению крутого спуска (вниз). Это помогает нам обновить параметры модели (веса и смещения) более точно.
Чтобы добраться до местных минимумов, мы не можем просто перейти прямо к точке (на графическом участке). Нам нужно спуститься в меньшие шаги и проверять минимумы и сделать еще один шаг к направлению спуска, пока мы не получим нашего желаемого местного минимума.
Небольшие шаги, упомянутые выше, называются как скорость обучения. Если скорость обучения очень маленькая, точность больше, но очень много времени. И большая ставка обучения может привести нас к минимальному (превышению). Теория состоит в том, чтобы использовать скорость обучения при более высокой скорости, пока наклон кривой не начнет уменьшать рекламу, как только он начнет уменьшаться, мы начинаем использовать меньшие скорости обучения (меньше времени и более точностей).
Функция затрат помогает нам оценить, насколько хороша наша модель функционирует или прогнозирует. Его Функция потери Отказ У него есть своя кривая и параметры (веса и смещение). Наклон кривой помогает нам соответственно обновлять наши параметры. Чем меньше стоит больше прогнозируемой вероятности.
На этапе обучения мы находим значение y_train, чтобы найти, сколько стоит отклонение от данного вывода. Затем мы рассчитаем ошибку затрат на данной второй фазе, используя формулу ошибки затрат.
стоимость = (1/N) * Σ (y i – Y_TRAIN) 2 {я от 1 до n}
for i in range(n_iters):
#Training phase
y_train = np.dot(X, self.weights) + self.bias
#Cost error calculating Phase
cost = (1 / n_samples) * np.sum((y_train - y)**2)
costs.append(cost)
Теперь мы обновляем веса и смещение, чтобы уменьшить нашу ошибку, делая
#Updating the weight and bias derivatives
Delta_w = (2 / n_samples) * np.dot(X.T, (y_hat - y))
Delta_b = (2 / n_samples) * np.sum((y_hat - y))
#Updating weights
self.weights = self.weights - learn_rate * Delta_w
self.bias = self.bias - learn_rate * Delta_b
# end of loop
А также Функция затрат на поговорку против итераций
Стоимость против итераций
Вышеведено приведенное выше кривая функции стоимости против количества итераций. В качестве количества итераций увеличивается (шаги) Стоимость снизилась, что значительно означает минимум близко и почти становится ноль. Мы делаем вышеупомянутые обновления, пока ошибка не станет незначительный или минимум достигнут.
Исходный код с нуля
class LinearModel:
"""
Linear Regression Model Class
"""
def __init__(self):
pass
def gradient_descent(self, X, y, learn_rate=0.01, n_iters=100):
"""
Trains a linear regression model using gradient descent
"""
n_samples, n_features = X.shape
self.weights = np.zeros(shape=(n_features,1))
self.bias = 0
self.prev_weights = []
self.prev_bias = []
self.X = X
self.y = y
costs = []
for i in range(n_iters):
""""
Training Phase
"""
y_hat = np.dot(X, self.weights) + self.bias
"""
Cost error Phase
"""
cost = (1 / n_samples) * np.sum((y_hat - y)**2)
costs.append(cost)
"""
Verbose: Description of cost at each iteration
"""
if i % 200 == 0:
print("Cost at iteration {0}: {1}".format(i,cost))
"""
Updating the derivative
"""
Delta_w = (2 / n_samples) * np.dot(X.T, (y_hat - y))
Delta_b = (2 / n_samples) * np.sum((y_hat - y))
""""
Updating weights and bias
"""
self.weights = self.weights - learn_rate * Delta_w
self.bias = self.bias - learn_rate * Delta_b
"""
Save the weights for visualisation
"""
self.prev_weights.append(self.weights)
self.prev_bias.append(self.bias)
return self.weights, self.bias, costs
def predict(self, X):
"""
Predicting the values by using Linear Model
"""
return np.dot(X, self.weights) + self.bias
# We have created our Linear Model class. Now we need to create and load our model. model = LinearModel() w_trained, b_trained, costs = model.gradient_descent(X_train, y_train, learn_rate=0.005, n_iters=1000)
def visualize_training(self):
"""
Visualizing the line against the dataset
"""
self.prev_weights = np.array(self.prev_weights)
x = self.X[:, 0]
line, = ax.plot(x, x, color='red')
ax.scatter(x, self.y)
def animate(line_data):
m, c = line_data
line.set_ydata(m*x + c) # update the data
return line,
def init():
return line,
def get_next_weight_and_bias():
for i in range(len(self.prev_weights)):
yield self.prev_weights[i][0], self.prev_bias[i]
return animation.FuncAnimation(fig, animate, get_next_weight_and_bias, init_func=init,interval=35, blit=True)
# Visualization of training phase to get the best fit line fig, ax = plt.subplots() ani = model.visualize_training() plt.show()
# Prediction Phase to test our model
n_samples, _= X_train.shape
n_samples_test, _ = X_test.shape
y_p_train = model.predict(X_train)
y_p_test = model.predict(X_test)
error_train = (1 / n_samples) * np.sum((y_p_train - y_train) ** 2)
error_test = (1 / n_samples_test) * np.sum((y_p_test - y_test) ** 2)
print("Error on training set: {}".format(np.round(error_train, 6)))
print("Error on test set: {}".format(np.round(error_test, 6)))
# Plotting predicted best fit line
fig = plt.figure(figsize=(8,6))
plt.scatter(X_train, y_train)
plt.scatter(X_test, y_p_test)
plt.xlabel("x")
plt.ylabel("y")
plt.show()
Проверьте полный исходный код для Градиентный спуск на Github а также проверьте другие подходы в Линейная регрессия на ML-царапин
Вкладчик
Эта серия сделана возможным благодаря помощи:
- PraNav ( @devarakondapranav )
- ОЗУ ( @ r0mflip )
- Девика ( @ devikamadupu1 )
- Пратюша ( @Prathyushakallepu )
- Pranay ( @ Pranay9866 )
- Subhasri ( @subhasrir )
- Laxman ( @lmn )
- Вайшнави ( @Vaishnavipulluri )
- Сурай ( @ Suraj47 )
Оригинал: “https://dev.to/ml_scratch/mls-1-b-gradient-descent-in-linear-regression-53dl”