梯度下降法实现-python[转载]

转自:https://www.jianshu.com/p/c7e642877b0e

梯度下降法，思想及代码解读。

import numpy as np

# Size of the points dataset.
m = 20

# Points x-coordinate and dummy value (x0, x1).
X0 = np.ones((m, 1))#返回一个m行1列的矩阵
X1 = np.arange(1, m+1).reshape(m, 1)#相当于是转置了
X = np.hstack((X0, X1))#要求行数必须相同

# Points y-coordinate
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)

# The Learning Rate alpha.
alpha = 0.01

def error_function(theta, X, y):
    '''Error function J definition.'''#定义损失函数
    diff = np.dot(X, theta) - y   #m行1列的列向量
    return (1./2*m) * np.dot(np.transpose(diff), diff)

def gradient_function(theta, X, y):
    '''Gradient of the function J definition.'''#定义梯度函数
    diff = np.dot(X, theta) - y
    return (1./m) * np.dot(np.transpose(X), diff)

def gradient_descent(X, y, alpha):
    '''Perform gradient descent.'''
    theta = np.array([1, 1]).reshape(2, 1)
    gradient = gradient_function(theta, X, y)
    while not np.all(np.absolute(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('error function:', error_function(optimal, X, y)[0,0])

梯度的方向即函数上升最快的方向。而加上负号表示朝着相反的方向前进。

初学python语法解读：

1.numpy.ones(shape,dataType,order='C')

其中shape=一个int数或者一个int数序列。dataType一般不选吧，可选的是np.int或者np.float。order：是否将多维数据存储在存储器中的C或FORTRAN连续（行或列）顺序中。(order一般编程不用考虑吧)

栗子1：x=np.ones((3,2))
          print(x)

输出:
[[1. 1.]
[1. 1.]
[1. 1.]]#输出全为1的float型的吧。

栗子2：x=np.ones(3)
          print(x)
输出：
[1. 1. 1.] #也就是说只有一个int的时候输入就是行向量，输入的int表示有几列。

2.numpy.arange([start,]stop,[step,]dataType=None)

start就是开始，stop是结束。用[]括起来的意思是可选的，不是非必需的参数。step默认是1.关于dataType如果没有指定则和输入的数据类型一致。

#注意这个函数不是arrange，是a range合起来。范围是左闭右开。最后输出的是一个数组，行向量，返回ndarray。

x=np.arange(3)
print(x)

#output[0 1 2]

x=np.arange(1,3,0.5)
print(x)

#output:[1.  1.5 2.  2.5]

3.np.ndarray.reshape(shape,order='C')

对ndarray返回一个shape型的矩阵。

m=3
X1 = np.arange(1, m+1).reshape(m, 1)#变成一个3行一列的列向量
print(X1)

输出：
[[1]
 [2]
 [3]]

4.np.hstack(tup)

就是将两个相同形状的矩阵在列上水平方向上合并起来。

a=np.array([[1,2],[3,4]])
b=np.array([[5,6],[7,8]])
c=np.hstack((a,b))
print(c)
#a，b是两行两列的矩阵，在水平方向上合并，在行上合并，即水平方向上。
输出：
[[1 2 5 6]
 [3 4 7 8]]

5.np.dot(a,b,out=None)

对于二维的来说就是矩阵a,b的乘积，对于一维来说就是向量的内积。

a = [[1, 0], [0, 1]]
b=[[4, 1], [2, 2]]
print(np.dot(a,b))

输出：
[[4 1]
 [2 2]]

6.np.transpose(a,axis=None)

顾名思义就是转置矩阵。

a = np.arange(4).reshape((2,2))
print(np.transpose(a))

输出：
[[0 2]
 [1 3]]