python 梯度卷积 代码 python求梯度函数

一、什么是“梯度下降法”

首先，我们有一个可微分的函数。这个函数就代表着一座山。我们的目标就是找到这个函数的最小值，也就是山底。根据之前的场景假设，最快的下山的方式就是找到当前位置最陡峭的方向，然后沿着此方向向下走，对应到函数中，就是找到给定点的梯度 ，然后朝着梯度相反的方向，就能让函数值下降的最快！因为梯度的方向就是函数之变化最快的方向
所以，我们重复利用这个方法，反复求取梯度，最后就能到达局部的最小值，这就类似于我们下山的过程。而求取梯度就确定了最陡峭的方向，也就是场景中测量方向的手段。

单变量的微分，函数只有一个变量时

多变量的微分，当函数有多个变量的时候，即分别对每个变量进行求微分

梯度：

在单变量的函数中，梯度其实就是函数的微分，代表着函数在某个给定点的切线的斜率
在多变量函数中，梯度是一个向量，向量有方向，梯度的方向就指出了函数在给定点的上升最快的方向

梯度的方向是函数在给定点上升最快的方向，那么梯度的反方向就是函数在给定点下降最快的方向

数学公式：

解释：J是关于Θ的一个函数，我们当前所处的位置为Θ0点，要从这个点走到J的最小值点，也就是山底。首先我们先确定前进的方向，也就是梯度的反向，然后走一段距离的步长，也就是α，走完这个段步长，就到达了Θ1这个点

二、梯度下降法求极值问题

问题：

求

的极小值点

1、初始点：

2、学习率：λ

3、梯度计算：

4、初始值的梯度：

5、更新迭代公式：

6、重复并总结：

7、不断重复迭代过程

三、最小二乘法求线性回归问题（python编程）

定义数据及设置相关数值并进行线性回归

from sklearn import linear_model        
#可以调用sklearn中的linear_model模块进行线性回归
import numpy as np
import matplotlib.pyplot as plt
# 定义数据集的大小 即20个数据点
m = 20
# x的坐标以及对应的矩阵
X0 = np.ones((m, 1))  # 生成一个m行1列的向量，其值全是1
X1 = np.arange(1, m+1).reshape(m, 1)  # 生成一个m行1列的向量，也就是x1，从1到m
X = np.hstack((X0, X1))  # 按照列堆叠形成数组，其实就是样本数据
# 对应的y坐标
Y = np.array([
	    3, 4, 5, 5, 2, 4, 7, 8, 11, 8, 12,
	    11, 13, 13, 16, 17, 18, 17, 19, 21
	]).reshape(m, 1)
	#进行线性回归的求解
model = linear_model.LinearRegression()
model.fit(X1,Y) 
print("斜率=",model.coef_[0])
print("截距为=",model.intercept_)

线性结果绘制：

# 根据数据画出对应的图像
def plot(X, Y, theta):
    ax = plt.subplot(111)  # 将画布分为1行1列，取第一个
    ax.scatter(X, Y, s=30, c="blue", marker="s")
    plt.xlabel("X")
    plt.ylabel("Y")
    x = arange(0, 21, 0.2)  # x的范围
    y =  model.intercept_+ model.coef_[0]*x
    ax.plot(x, y)
    plt.show()

plot(X1, Y, model.coef_[0])

四、梯度下降法求线性回归问题（python编程）

定义数据及设置相关数值

from numpy import *
# 定义数据集的大小 即20个数据点
m = 20
# x的坐标以及对应的矩阵
X0 = ones((m, 1))  # 生成一个m行1列的向量，其值全是1
X1 = arange(1, m+1).reshape(m, 1)  # 生成一个m行1列的向量，也就是x1，从1到m
X = hstack((X0, X1))  # 按照列堆叠形成数组，其实就是样本数据
# 对应的y坐标
Y = np.array([
    3, 4, 5, 5, 2, 4, 7, 8, 11, 8, 12,
    11, 13, 13, 16, 17, 18, 17, 19, 21
]).reshape(m, 1)
# 学习率
alpha = 0.01
import matplotlib.pyplot as plt
#绘制出数据集
plt.scatter(X1,Y,color='red')
plt.show()

代价函数定义及代价函数的梯度函数

# 定义代价函数
#损失函数（loss function）或代价函数（cost function）是将随机事件或其有关随机变量的取值映射为非负实数以表示该随机事件的“风险”或“损失”的函数
def cost_function(theta, X, Y):
    diff = dot(X, theta) - Y  # dot() 数组需要像矩阵那样相乘，就需要用到dot()
    return (1/(2*m)) * dot(diff.transpose(), diff)
    
# 定义代价函数对应的梯度函数
def gradient_function(theta, X, Y):
    diff = dot(X, theta) - Y
    return (1/m) * dot(X.transpose(), diff)
    # 梯度下降迭代
def gradient_descent(X, Y, alpha):
    #将[1,1]变为2行1列的形式
    theta = array([1, 1]).reshape(2, 1)
    #得到代价函数的初始梯度
    gradient = gradient_function(theta, X, Y)
    #不断迭代的过程
    while not all(abs(gradient) <= 1e-5):
    	#更新迭代公式
        theta = theta - alpha * gradient
        #更新迭代所用的梯度
        gradient = gradient_function(theta, X, Y)
    return theta

#梯度下降最终的结果
optimal = gradient_descent(X, Y, alpha)
print('optimal:', optimal)
print('cost function:', cost_function(optimal, X, Y)[0][0])

线性结果绘制

# 根据数据画出对应的图像
def plot(X, Y, theta):
    ax = plt.subplot(111)  # 将画布分为1行1列，取第一个
    ax.scatter(X, Y, s=30, c="red", marker="s")
    plt.xlabel("X")
    plt.ylabel("Y")
    x = arange(0, 21, 0.2)  # x的范围
    y = theta[0] + theta[1]*x
    ax.plot(x, y)
    plt.show()

plot(X1, Y, optimal)