首页手记【学习打卡】第14天 Python3入门机器学习

【学习打卡】第14天 Python3入门机器学习

标签：

Python 机器学习

课程介绍

课程名称：Python3入门机器学习经典算法与应用入行人工智能
课程章节：6-1；6-2；6-3；6-4
主讲老师：liuyubobobo

内容导读

第一部分梯度下降与学习率
第二部分封装函数并研究学习率
第三部分线性回归中的梯度下降法
第四部分代码展示

课程详细

- 第一部分梯度下降与学习率

本身不是一个机器学习算法，不能解决分类或者回归问题
是一种基于搜索的最优化方法
作用：最小化一个损失函数
梯度上升法：最大化一个效用函数

#自己搞出一条线条X,Y来进行模拟梯度下降中的J与theta
import numpy as np
import matplotlib.pyplot as plt
plot_x = np.linspace(-1, 6, 141)
plot_y = (plot_x - 2.5)**2 -1

plt.plot(plot_x, plot_y)
plt.show()

#对j进行求导
def dJ(theta):
    return 2*(theta-2.5)

#确定损失函数是多少
def J(theta):
    return (theta - 2.5)**2 -1

#学习率
eta = 0.1
#初始化参数
theta = 0.0
#退出循环的条件：上一个J值与下一个J值差值，小于epsilon
epsilon = 1e-8
#保存theta变化的情况，用于后续绘图
history_theta = [theta]
while True:
    #把每次求出的倒数，放到gradient中
    gradient = dJ(theta)
    #保存上一个theta的值
    last_theta = theta
    #对theta进行求导找出方向，然后梯度下降
    theta = theta - eta * gradient
    ##保存theta历史数据
    history_theta.append(theta)
    #退出循环条件一
    if (abs(J(theta) - J(last_theta)) < epsilon):
        break

plt.plot(plot_x, J(plot_x))
plt.scatter(history_theta,J(np.array(history_theta)), color='r', marker="+")
plt.show()

- 第二部分封装函数并研究学习率

def gradient_descent(initial_theta, eta, epsilon=1e-8):
    theta = initial_theta
    theta_history.append(initial_theta)
    
    while True:
        #把每次求出的倒数，放到gradient中
        gradient = dJ(theta)
        #保存上一个theta的值
        last_theta = theta
        #对theta进行求导找出方向，然后梯度下降
        theta = theta - eta * gradient
        ##保存theta历史数据
        theta_history.append(theta)
        #退出循环条件一
        if (abs(J(theta) - J(last_theta)) < epsilon):
            break
def plot_theta_history():
    plt.plot(plot_x, J(plot_x))
    plt.plot(np.array(theta_history), J(np.array(theta_history)), color="r", marker="+" )
    plt.show()

学习率较小的情况

eta = 0.01
theta_history = []
gradient_descent(0., eta)
plot_theta_history()
len(theta_history)
#运行了423次，由图也可以看出，循环了很多次

学习率稍小的情况

eta = 0.3
theta_history = []
gradient_descent(0., eta)
plot_theta_history()

len(theta_history)
#运行了13次，由图也可以看出，找对学习率是能提升运算效率，不过最重要的是找到极值，而非找到最好的学习率

学习率稍大的情况

eta = 0.8
theta_history = []
gradient_descent(0., eta)
plot_theta_history()

len(theta_history)
#运行了22次，由图也可以看出，曲线一下左一下右，但是似乎也是在下降的过程，最终运行22次达到了极值点附近

学习率太大的情况

eta = 1.1
theta_history = []
gradient_descent(0., eta)
plot_theta_history()
#报错了，应为J发散了，越来越大
#这时候调整，J函数要是报错就返回inf也就是i无穷大
#和给梯度下降函数增加一个num退出循环条件
#OverflowError: (34, 'Result too large')

#修改后出错就返回正无穷
def J(theta):
    try:
        return (theta-2.5) ** 2 - 1
    except:
        return float('inf')

def gradient_descent(initial_theta, eta, n_iters = 1e4, epsilon=1e-8):
    
    theta = initial_theta
    i_iter = 0
    theta_history.append(initial_theta)

    while i_iter < n_iters:
        gradient = dJ(theta)
        last_theta = theta
        theta = theta - eta * gradient
        theta_history.append(theta)
    
        if(abs(J(theta) - J(last_theta)) < epsilon):
            break
            
        i_iter += 1
       
    return
    
eta = 1.1
theta_history = []
gradient_descent(0, eta)
#修改后是可以运行的，

eta = 1.1
theta_history = []
gradient_descent(0, eta, n_iters=5)
plot_theta_history()
#它发散了

从这几幅图可以清晰地看出来，学习率选择的重要性，当你发现你的J损失函数，无穷大的时候，那就要检查一下是不是发散了，同时可以试着减小学习率

- 第三部分线性回归中的梯度下降法

#导入代码
import numpy as np
import matplotlib.pyplot as plt

#创建数据
np.random.seed(666)
x = 2 * np.random.random(size=100)
y = x * 3. + 4.+ np.random.normal(size=100)

#更改格式
X = x.reshape(-1,1)
X.shape

plt.scatter(x, y)
plt.show()

#计算J的值
def J(theta, X_b, y):
    try:
        return np.sum((y - X_b.dot(theta) ) ** 2) / len(X_b)
    except:
        return float('inf')

#计算J的导数
def dJ(theta, X_b, y):
    res = np.empty(len(theta))
    res[0] = np.sum(X_b.dot(theta) - y)
    for i in range(1, len(theta)):
        print(i,X_b[:,i])
        res[i] = np.sum((X_b.dot(theta) - y).dot(X_b[:,i]))
    
    return res * 2 / len(X_b)

#改进版-向量化
def dJ(theta, X_b, y):
    reg = np.array(X_b.dot(theta) - y).dot(X_b)
    return reg * 2 / len(X_b)

def gradient_descent(X_b, y ,initial_theta, eta, n_iters = 1e4, epsilon=1e-8):
    
    #初始化，theta的值，运行次数的值，theta历史的数字
    theta = initial_theta
    i_iter = 0
    theta_history = []
    theta_history.append(initial_theta)
    
    #运行次数超过1万次就退出循环条件1
    while i_iter < n_iters:
        
        #求导数
        gradient = dJ(theta, X_b, y)
        #赋值历史theta，用于判断退出循环条件2
        last_theta = theta
        #梯度下降，
        theta = theta - eta * gradient
        #写入历史记录
        theta_history.append(theta)
        #推出条件，J与上一个J的值差距小于1e-8
        if(abs(J(theta, X_b, y) - J(last_theta, X_b, y)) < epsilon):
            break
        #用于记录运行次数
        i_iter += 1
        
    return theta
#合并，在X前插入全1向量
X_b = np.concatenate([np.ones((len(X),1)),X ],axis=1)
#随机化系数
theta = np.array(np.random.randint(1,100,X_b.shape[1]))
eta = 0.01

theta = gradient_descent(X_b, y, theta, eta)
#array([4.02145777, 3.00706285])
#准确无误
#成功训练出模型

进行封装代码，并调用

from nike.LinearRegression import LinearRegression

lin_reg = LinearRegression()
lin_reg.fit_gd(X, y)

lin_reg.coef_
#array([3.00328737])
lin_reg.intercept_
#4.025934058956716

- 第四部分代码展示

import numpy as np
from .metrics import r2_score


class LinearRegression:

    def __init__(self):
        """初始化多元线性回归模型"""
        #初始化截距coef_和系数interception_，和theta私有化参数
        self.coef_ =  None
        self.intercept_ = None
        self._theta = None

    def fit_normal(self, X_train ,y_train):
        assert X_train.shape[0] ==y_train.shape[0],\
            "the size of X_train must be equal to the size of y_train"
        #ones(多少个,0or1行和列)
        X_b = np.concatenate(([np.ones((len(X_train), 1)), X_train]), axis=1)
        self._theta = np.linalg.pinv(X_b.T.dot(X_b)).dot(X_b.T).dot(y_train)

        self.intercept_ = self._theta[0]
        self.coef_ = self._theta[1:]

        return self
    def fit_gd(self,X_train, y_train, eta=0.01, n_iters=1e4, epsilon=1e-8):

        assert X_train.shape[0] == y_train.shape[0], \
            "the size of X_train must be equal to the size of y_train"

        # 计算J的值
        def J(theta, X_b, y):
            try:
                return np.sum((y - X_b.dot(theta)) ** 2) / len(X_b)
            except:
                return float('inf')

        # 计算J的导数
        def dJ(theta, X_b, y):
            reg = np.array(X_b.dot(theta) - y).dot(X_b)
            return reg * 2 / len(X_b)

        def gradient_descent(X_b, y, initial_theta, eta, n_iters=1e4, epsilon=1e-8):

            # 初始化，theta的值，运行次数的值，theta历史的数字
            theta = initial_theta
            i_iter = 0
            theta_history = []
            theta_history.append(initial_theta)

            # 运行次数超过1万次就退出循环条件1
            while i_iter < n_iters:

                # 求导数
                gradient = dJ(theta, X_b, y)
                # 赋值历史theta，用于判断退出循环条件2
                last_theta = theta
                # 梯度下降，
                theta = theta - eta * gradient
                # 写入历史记录
                theta_history.append(theta)
                # 推出条件，J与上一个J的值差距小于1e-8
                if (abs(J(theta, X_b, y) - J(last_theta, X_b, y)) < epsilon):
                    break
                # 用于记录运行次数
                i_iter += 1

            return theta

        # 合并，在X前插入全1向量
        X_b = np.concatenate([np.ones((len(X_train), 1)), X_train], axis=1)
        # 随机化系数
        initial_theta = np.array(np.random.randint(1, 100, X_b.shape[1]))

        self._theta = gradient_descent(X_b, y_train, initial_theta, eta)
        self.intercept_ = self._theta[0]
        self.coef_ = self._theta[1:]

        return self

    def predict(self,X_predict):
        assert self.intercept_ is not None and self.coef_ is not None,\
            'must fit before predict'
        assert X_predict.shape[1] == len(self.coef_),\
            'the feature number of X_predict must be equal to X_train'
        X_b = np.concatenate([np.ones((len(X_predict),1)),X_predict], axis=1)

        return X_b.dot(self._theta)

    def score(self, X_test, y_test):

        y_predict = self.predict(X_test)
        return r2_score(y_test, y_predict)

    def __repr__(self):
        return "LinearRegression()"

# if __name__ == '__main__':
#     X_b = np.concatenate([np.ones((10, 1)), np.ones((10, 1))], axis=1)
#     print(X_b)

课程思考

梯度下降的算法，有些求导的地方还是有点迷糊，还有numpy包的智能识别乘法，让我在调整好格式带入，老是出错，迷糊了半天，后来发现在数学上有些不能相乘的，他能自动识别进行转换格式，但是自己转换输入就会出错，要是没有老师代码对照着看，还真的很难发现。另外有时候一个括号之差就会导致程序出错，特别是在函数公式处，一定要详细检查格式，优先级等等。