机器学习二

线性回归

# -*- coding = utf-8 -*-
# @Author : 墙缝里的草
# @File : demo1004.py
# @Software : PyCharm

import numpy as np
import random
# 线性回归 的函数构造
'''
input_data   训练数据集
realresult   训练结果集
theta   参数



'''

# 线性回归函数
def _init_(self,input_data,realresult,theta=None):
    '''
    :param self:
    :param input_data: 输入数据
    :param realresult:  真实数据
    :param theta: 线性回归参数，默认为None
    :return:
    '''
    #     获得输入数据集的形状
    row,col=np.shape(input_data)
    #构造输出数据组
    self.InputData=[0]*row
    #给每组数据添加常数项1
    for(index,data)in enumerate(input_data):
        Data=[1.0]
        #把input_data扩展到Data内，把input_data的每一i组数据添加放到Data
        Data.extend(list(data))
        self.InputData[index]=Data
    self.InputData=np.array(self.InputData)
    self.Result=realresult
    #参数theta不为None时，利用theta构造模型函数
    if theat is not None:
        self.Theta=theta
    else:
        #随机生成服从标准正态分布的函数
        sel .Theta=np.random.normal((col+1,1))


# 梯度下降算法函数
def BGD(self,alpha):
    '''
    利用BGD算法进行一次迭代调整参数的函数
    :param self:
    :param alpha: 学习率
    :return:
    '''
    #定义梯度增量数组
    gradient_increasment=[]
    #对其输入的数据机器真是结果进行依次遍历
    for (input_data,real_result) in zip(self.InputData,self.Result):
        #计算每组input_data的梯度增量，并放入梯度增量数组
        g=(real_result-input_data.dot(self.Theta))*input_data
        gradient_increasment.append(g)
    #按列计算属性的平均梯度增量
    avg_g=np.average(gradient_increasment,0)
    #改变平均梯度增量数组形状
    avg_g=avg_g.reshape((len(avg_g),1))
    #更新模型参数 self.Theta
    self.Theta=self.Theta+alpha*avg_g



# 随机梯度下降算法函数
def SGD(self,alpha):
    '''
    利用SGD算法进行一次迭代调整参数的函数
    :param self:
    :param alpha:学习率
    :return:
    '''
    #首先将数据集随机打乱，减少数据集顺序对参数调优的影像
    shuffle_sequence=self.Shuffle_Squence()
    self.InputData=self.InputData[shuffle_sequence]
    self_Resule=self.Result[shuffle_sequence]
    #对训练数据集进行遍历，利用每组数据对参数进行调整
    for(input_data,real_result) in zip(self.InputData,self_Resule):
        #计算每组input_data的梯度增量
        g=(real_result-input_data.dot(self.Theta))*input_data
        #调整每组input_data的梯度增量的形状
        g=g.reshape((len(g),1))
        #更新参数模型
        self_Theta=self_Theta+alpha.g



#小批量梯度下降算法函数
def MBGD(self,alpha,batch_size):
    '''
      利用MBGD算法进行一次迭代调整参数的函数
    :param self:
    :param alpha:
    :param batch_size:
    :return:
    '''
    #首先将数据集随机打乱，减少数据集顺序对参数调优的影响
    shuffle_sequence=self.Shuffle_Squence()
    self.InputData=self.InputData[shuffle_sequence]
    self.Result=self.Result[shuffle_sequence]
    #遍历每个小批量样本
    for start in np.arange(0,len(shuffle_sequence),batch_size):
        #判断start+batch_size是否大于数组长度
        #防止最后一组小批量杨副本规模可能小于batch_size的情况
        end=np.min([start+batch_size,len(shuffle_sequence)])
        #获取训练小批量样本集及其标签
        mini_batch=shuffle_sequence[start:end]
        Mini_Train_Data=self.InputData[mini_batch]
        Mini_Train_Result=self.Result[mini_batch]
        #定义梯度增量数组
        gradient_increasement=[]
        #对小样本训练集进行遍历，利用每个小样本的梯度增量的平均值对模型参数进行更新
        for (data,result) in zip(Mini_Train_Data,Mini_Train_Result):
            #计算每组input_data的梯度增量，并放入梯度增量数组
            g=(result-data.dot(self,Theta))*data
            gradient_increasement.append(g)
        #按列计算每组小样本训练集的梯度增量的平均值，并改变其形状
        avg_g=np.average(gradient_increasement,0)
        avg_g=avg_g.reshape((len(avg_g),1))
        #更新 模型参数
        self.Theta=self.Theta+alpha*avg_g


'''
迭代训练函数
'''
def train_BGD(self,iter,alpha):
    '''
    利用BGD算法迭代优化的函数
    :param self:
    :param iter: 迭代次数
    :param alpha:   优化率
    :return:
    '''
    #定义平均 训练损失数组，记录每轮迭代的训练数组集的损失
    Cost=[]
    #开始训练进行迭代
    for i in range(iter):
        #利用学习率alpha，结合BGD算法模型进行训练
        self.BGD(alpha)
        #记录每次迭代的平均损失
        Cost.append(self.Cost())
    Cost=np.array(Cost)
    return Cost

def train_SGD(self,iter,alpha):
    '''
     利用SGD算法迭代优化的函数
    :param self:
    :param iter:
    :param alpha:
    :return:
    '''
    # 定义平均 训练损失数组，记录每轮迭代的训练数组集的损失
    Cost = []
    # 开始训练进行迭代
    for i in range(iter):
        # 利用学习率alpha，结合SGD算法模型进行训练
        self.SGD(alpha)
        # 记录每次迭代的平均损失
        Cost.append(self.Cost())
    Cost = np.array(Cost)
    return Cost

def train_MBGD(self,iter,batch_size,alpha):
    '''
     利用MBGD算法迭代优化的函数
    :param self:
    :param iter:
    :param batch_size:
    :param alpha:
    :return:
    '''
    # 定义平均 训练损失数组，记录每轮迭代的训练数组集的损失
    Cost = []
    # 开始训练进行迭代
    for i in range(iter):
        # 利用学习率alpha，结合MBGD算法模型进行训练
        self.MBGD(alpha)
        # 记录每次迭代的平均损失
        Cost.append(self.Cost())
    Cost = np.array(Cost)
    return Cost


'''
正则方程函数
'''

def getNormalEquation(self):
    '''
    利用正则方程计算模型参数self.Theta
    :param self:
    :return:
    '''


    # 0.001*np.eye(np.shape(self.InputData.T))是防止出现原始XT的行列式为0，即防止原始XT不可逆
    #获取输入数据数组形式
    col,rol=np.shape(self.InputData.T)
    #计算输入数据矩阵的转置
    XT=self.InputData.T+0.001*np.eye(col,rol)
    #

# -*- coding = utf-8 -*-
# @Author : 墙缝里的草
# @File : demo1.py
# @Software : PyCharm


import numpy as np
def  _init_(self,train_data,train_result):
    '''

    :param self:
    :param train_data: 输入训练数据
    :param train_result:  训练数据真实结果
    :return:
    '''
    #获得输入数据集的形状
    row,col=np.shape(train_data)

    #构造输入数据数组
    self.Train_Data=[0]*row
    #给每组输入数据增添常数项1
    for(index,data) in enumerate(train_data):
        Data=[1.0]
    #把每组data扩展到Data内
        Data.extend(list(data))
        self.Train_Data[index]=Data
    self.Train_Data=np.array(self.Train_Data)
#构造输入数据对应的结果
    self.Train_Result=train_result
#定义数据权重
    self.weight=np.zeros((row,row))
    #定义局部加权线性回归的模型参数
    self.Theta=[]



def Gaussian_Weight(self,data,k):
    '''
    计算测试权重的函数
    :param self:
    :param data:   输入数据
    :param k:   带宽系数
    :return:
    '''
    #data类型数据是np.array，则利用dot方法
    #惊醒矩阵运算的结果是矩阵，只有一个元素也是
    sum=np.sum(data*data)
    return np.exe(sum/(-2.0*k**2))