精华内容
下载资源
问答
  • 线性回归python
    千次阅读
    2021-06-20 09:43:54

    机器学习

    第一章:机器学习基础 第二章:线性回归 第三章:逻辑回归 第四章:BP 神经网络 第五章:卷积神经网络 第六章:循环神经网络 第七章:决策树与随机森林 第八章:支持向量机 第九章:隐马尔科夫 第十章:聚类等算法 ...

    github地址


    前言

    机器学习是从人工智能中产生的一个重要学科分支,是实现智能化的关键


    一、多变量线性回归?

    前面我们讲过单变量线性回归,就是只要一变量的线性回归,今天我们要讲的这个多变量线性回归,顾名思义就是由多个变量的线性回归。
    多变量回归的一般形式如下:
    在这里插入图片描述
    a代表截距,b1,b2,…,bk为回归系数。

    3.1 吴恩达多变量线性回归练习

    通过学习吴恩达的课程,我完成其多变量线性回归题,一共两个case

    3.1.1 版本一

    
    # 开发时间 ;2021/5/13 0013 13:24
    #房价预测
    
    #加载库
    import numpy as np
    import matplotlib.pyplot as plt
    import pandas as pd
    
    #加载数据集
    #第一列是房子的大小(平方英尺),第二列是卧室的数量,第三列是房子的价格。
    data=pd.read_csv('F:\\ML\\线性回归\\数据文件\\ex1data2.txt',names=['size','num_bedroom','price'],header=None)
    #print(data.head(5))
    '''
       size  num_bedroom   price
    0  2104            3  399900
    1  1600            3  329900
    2  2400            3  369000
    3  1416            2  232000
    4  3000            4  539900
    '''
    
    
    #归一化处理
    '''
    特征缩放/归一化
    对于多特征的机器学习问题,如果这些特征的取值在相近的范围内,则梯度下降法就能更快的收敛。
    例如,考虑取值范围相差较大的两个特征的情况,损失函数等值线将呈现出扁椭圆形,相差倍数越大,椭圆越扁。
    在这样的等值线上运行梯度下降,需要花很长一段时间,并可能来回波动,最终收敛到全局小值。
    改善这一状况的有效做法是特征缩放,使两个特征的取值范围靠近。此时损失函数等值线更接近圆,
    从数学上可以证明,梯度下降会找到一条更直接的路径(迭代次数减少)通向全局最小值。
    常用方法:除最大值,均值归一化等。
    
    在此实例中,房子的大小大约是卧室数量的1000倍。当特征有不同的数量级时,首先执行特征缩放可以使梯度下降收敛得更快。
    '''
    data=(data-data.mean())/data.std()
    #print(data.head(5))
    '''
           size  num_bedroom     price
    0  0.130010    -0.223675  0.475747
    1 -0.504190    -0.223675 -0.084074
    2  0.502476    -0.223675  0.228626
    3 -0.735723    -1.537767 -0.867025
    4  1.257476     1.090417  1.595389
    '''
    data.insert(0,'Ones',1) # 就是在第一列[0] 添加名字为Ones的一列数据,数值都是1
    X=data.iloc[:,:-1]#所有行,不取倒数第一列
    # y=data.iloc[:,3:4]
    y=data.iloc[:,-1]
    theta=np.zeros(X.shape[1])
    m=len(X)
    alpha=0.01
    #代价函数
    
    def Cost_function(X,y,theta):
        inner=(np.dot(X,theta)-y)**2
        return np.sum(inner)/2*m
    
    #梯度下降
    def gradient(X,y,theta):
        i=0
        for i in range(1000):
            i+=1
            theta=theta-(alpha/m)*np.dot(X.T,(np.dot(X,theta)-y))
        return theta
    
    theta=gradient(X,y,theta)
    print(theta)
    
    

    3.1.2 版本二

    import pandas
    import numpy as np
    import matplotlib.pyplot as plt
    
    
    def normalization(X):
        '''
        归一化
        :param X:
        :return:
        '''
        mu = np.mean(X, axis=0)
        # ddof的设置,会改变标准差的结算结果,因为总体误差和样本误差的计算公式不一样
        #标准差
        sigma = np.std(X, axis=0, ddof=1)
        X_norm = (X-mu)/ sigma
        return X_norm, mu, sigma
    
    
    def computeCostMulti(X, y, theta):
        """
        计算损失函数
        :param X:
        :param y:
        :param theta:
        :return:
        """
        m = X.shape[0]
        costs = X.dot(theta) - y
        total_cost = costs.transpose().dot(costs) / (2 * m)
        return total_cost[0][0]
    
    
    def gradientDescentMulti(X, y, theta, alpha, iterNum):
        """
        梯度下降实现
        :param X:
        :param y:
        :param theta:
        :param alpha:
        :param iterNum:
        :return:
        """
        m = len(X)
    
        J_history = list()
    
        for i in range(0, iterNum):
            costs = X.dot(theta) - y
            theta = theta - np.transpose(costs.transpose().dot(X) * (alpha / m))
    
            J_history.append(computeCostMulti(X, y, theta))
    
        return theta, J_history
    
    
    def learningRatePlot(X_norm, y):
        """
        不同学习速率下的梯度下降比较
        :param X_norm:
        :param y:
        :return:
        """
        colors = ['b', 'g', 'r', 'c', 'm', 'y', 'k']
        plt.figure()
        iter_num = 50
        # 如果学习速率取到3,损失函数的结果随着迭代次数增加而发散,值越来越大,不太适合在同一幅图中展示
        for i, al in enumerate([0.01, 0.03, 0.1, 0.3, 1]):
            ta = np.zeros((X_norm.shape[1], 1))
            ta, J_history = gradientDescentMulti(X_norm, y, ta, al, iter_num)
    
            plt.plot([i for i in range(len(J_history))], J_history, colors[i], label=str(al))
    
        plt.title("learning rate")
        plt.legend()
        plt.show()
    
    
    def normalEquation(X, y):
        """
        正规方程实现
        :param X:
        :param y:
        :return:
        """
        return np.linalg.inv(X.transpose().dot(X)).dot(X.transpose()).dot(y)
    
    
    if __name__ == '__main__':
        # 读取数据
        data_path = r'F:\\ML\\线性回归\\数据文件\\ex1data2.txt'
        data = pandas.read_csv(data_path, delimiter=",", header=None)
    
        # 切分特征和目标, 注意:索引是从0开始的
        X = data.iloc[:, 0:2].values
        y = data.iloc[:, 2:3].values
    
        # 数据标准化
        X_norm, mu, sigma = normalization(X)
    
        ones = np.ones((X_norm.shape[0], 1))
    
        # 假设函数中考虑截距的情况下,给每个样本增加一个为1的特征
        X_norm = np.c_[ones, X_norm]
    
        # 初始化theta
        theta = np.zeros((X_norm.shape[1], 1))
    
        # 梯度下降学习速率为0.01
        alpha = 0.01
        # 梯度下降迭代次数为400
        iterNum = 400
    
        # 梯度下降
        theta, J_history = gradientDescentMulti(X_norm, y, theta, alpha, iterNum)
    
        # 画出梯度下降过程中的收敛情况
        plt.figure()
        plt.plot([i for i in range(len(J_history))], J_history)
        plt.title("learning rate: %f" % alpha)
        plt.show()
    
        # 使用不同学习速率下的收敛情况
        learningRatePlot(X_norm, y)
    
        # 预测面积为1650,卧室数量为3的房子价格
        x_pre = np.array([1650, 3])
    
        x_pre_norm = (x_pre - mu) / sigma
        numpy_ones = np.ones((1,))
        x_pre_norm = np.concatenate((np.ones((1,)), x_pre_norm))
        price = x_pre_norm.dot(theta)
        print("通过梯度下降求解的参数预测面积1650、卧室数量3的房子价格为:%f" % price[0])
    
        # 下面使用正规方程计算theta
        X_ = np.c_[ones, data.iloc[:, 0:2].values]
        y_ = data.iloc[:, 2:3].values
    
        theta = normalEquation(X_, y)
    
        # 预测面积为1650,卧室数量为3的房子价格
        x_pre = np.array([1, 1650, 3])
        price = x_pre.dot(theta)
        print("通过正规方程求解的参数预测面积1650、卧室数量3的房子价格为:%f" % price[0])
       
    

    在这里插入图片描述
    在这里插入图片描述
    通过梯度下降求解的参数预测面积1650、卧室数量3的房子价格为:289314.620338
    通过正规方程求解的参数预测面积1650、卧室数量3的房子价格为:293081.464335

    3.2 股票预测

    通过上述学习,我们完成简单的股票预测

    #数据获取
    #从大型数据网站www.quandl.com获取
    #开盘价open 最高价high 最低价low 收盘价close 交易额volume 调整后的开盘价Adj.Open 最高价Adj.High 最低价Adj.Low 收盘价Adj.Close 交易额Adj.volume
    # 1 关于Quandl
    # Quandl是为投资专业人士提供金融,经济和替代数据的首选平台,拥有海量的经济和金融数据。
    #
    # 2 Quandl模块
    # Python有Quandl模块,通过Quandl模块可直接使用平台上的数据。Quandl包可以访问平台上所有免费的数据,但不是所有的数据都是免费的,部分数据需要付费才能使用。
    import quandl
    from sklearn import preprocessing
    df=quandl.get('WIKI/GOOGL')#预测Google股票再用
    #df=quandl.get('WIKI/AAPL')
    import math
    import numpy as np
    #定义预测列变量,它存放研究对象的标签名
    forecast_col='Adj. Close'
    #定义预测天数,这里设置为所有数据量长度的1%
    forecast_out=int(math.ceil(0.01*len(df)))
    #只用到df中的下面几个字段
    df=df[['Adj. Open','Adj. High','Adj. Low','Adj. Close','Adj. Volume']]
    #构造两个新的列
    #HL_PCT为股票最高价与最低价的变化百分比
    df["HL_PCT"]=(df['Adj. High']-df['Adj. Close'])/df['Adj. Close']*100.0
    #PCT_change为股票收盘价与开盘价的变化百分比
    df["PCT_change"]=(df['Adj. Close']-df['Adj. Open'])/df['Adj. Open']*100.0
    #因为sciket-learn并不会处理空数据,需要把为空的数据都设置为一个比较难出现的值,我们设置为-9999
    df.fillna(-9999,inplace=True)
    #用label代表该字段,是预测结果
    #通过让Adj.Close列的数据往前移动1%行来表示
    df['label']=df[forecast_col].shift(-forecast_out)
    #最后生成真正在模型中使用的数据x,y,以及预测时用到的数据
    X=np.array(df.drop(['label'],1))
    X=preprocessing.scale(X)
    # 上面生成label列时留下的最后1%行的数据,这些行并没有label数据,因此我们可以拿他们作为预测时用到的输入数据
    X_lately = X[-forecast_out:]
    X=X[:-forecast_out:]
    #抛弃label列中为空的那些行
    df.dropna(inplace=True)
    y=np.array(df['label'])
    
    from sklearn import model_selection,svm
    from sklearn.linear_model import LinearRegression
    # 开始前,先X和y把数据分成两部分,一部分用来训练,一部分用来测试
    X_train,X_test,y_train,y_test=model_selection.train_test_split(X,y,test_size=0.25)
    #生成线性回归对象
    clf=LinearRegression(n_jobs=-1)
    #开始训练
    clf.fit(X_train,y_train)
    #用测试数据评估准确性
    accuracy=clf.score(X_test,y_test)
    #进行预测
    forecast_set=clf.predict(X_lately)
    print(forecast_set,accuracy)
    import matplotlib.pyplot as plt
    from matplotlib import style
    import datetime
    #修改matplotlib样式
    style.use('ggplot')
    one_day=86400
    #在df中新建Rorecast列,用于存放预测结果的数据
    df['Forecast'] = np.nan
    # 取df最后一行的时间索引
    last_date = df.iloc[-1].name
    last_unix = last_date.timestamp()
    next_unix = last_unix + one_day
    # 遍历预测结果,用它往df追加行
    # 这些行除了Forecast字段,其他都设为np.nan
    for i in forecast_set:
        next_date = datetime.datetime.fromtimestamp(next_unix)
        next_unix += one_day
        # [np.nan for _ in range(len(df.columns) - 1)]生成不包含Forecast字段的列表
        # 而[i]是只包含Forecast值的列表
        # 上述两个列表拼接在一起就组成了新行,按日期追加到df的下面
        df.loc[next_date] = [np.nan for _ in range(len(df.columns) - 1)] + [i]
    
    # 开始绘图
    df['Adj. Close'].plot()
    df['Forecast'].plot()
    plt.legend(loc=4)
    plt.xlabel('Date')
    plt.ylabel('Price')
    plt.show()
    

    总结

    期待大家和我交流,留言或者私信,一起学习,一起进步!

    更多相关内容
  • 线性回归python

    2019-04-12 14:32:56
    线性回归python,机器学习。
  • 二元线性回归,读取txt数据,三维可视化,注意读取数据时预处理很重要。
  • 线性回归Python代码

    2018-07-23 21:49:33
    线性回归是回归函数关于未知回归系数具有非线性结构的回归。常用的处理方法有回归函数的线性迭代法、分段回归法、迭代最小二乘法等。非线性回归分析的主要内容与线性回归分析相似。
  • 线性回归python实现

    2022-07-26 19:26:22
    线性回归是利用数理统计中回归分析,来确定两种或两种以上变量间相互依赖的定量关系的一种统计...本文首先介绍了最小二乘法求解线性回归的推到过程,然后使用python实现了最小二乘法,并对实验数据进行了简单评估......

    目录

    最小二乘法

    代码实现

    1 数据导入

    2 线性回归模型定义

     3 测试


    线性回归是利用数理统计中回归分析,来确定两种或两种以上变量间相互依赖的定量关系的一种统计分析方法,运用十分广泛。其表达形式为y = wx+b。

    一、最小二乘法

    一般来说,线性回归都可以通过最小二乘法求出其方程,可以计算出对于y=wx+b的直线。

    首先,直接给出w、b的解

     

    均方误差是回归任务中最常用的性能度量,因此我们试图让均方误差最小 

    由于均方差为凸函数,因此一定能找到最小值,我们对上式的w,b分别求偏导得:

    当偏导为0时,可以求得极小值w,b,如上所示。

    二、代码实现

    1 数据导入

    我们的数据在dada.csv中,每行为一组观察值,用逗号隔开,第一列为输入,第二列为输出

    import matplotlib.pyplot as plt
    import numpy as np
    
    points = np.genfromtxt('data.csv', delimiter=',')
    
    # 提取points中的两列数据,分别作为x,y
    x = points[:, 0]
    y = points[:, 1]
    
    # 用plt画出散点图
    plt.scatter(x, y)
    plt.show()

    2 线性回归模型定义

    class LinerRegression:
        def __init__(self, w=0.1, b=0.1):
            self.w = w
            self.b = b
    
        def fit(self,x,y):
            self.leasteq(x,y)
    
        def leastsq(self,x,y):
            self.w = np.sum(y * (x-np.mean(x))) / \
                     (np.sum(x*x) -  1/len(x) * np.sum(x) ** 2)
            self.b = 1/len(x) * np.sum(y- self.w*x)
    
        def predict(self,x,y):
            return self.w*x+self.b
    
        # 损失函数是系数的函数,另外还要传入数据的x,y
        def compute_cost(x,y):
            return np.mean((self.w*x + self.b - y)**2)

     3 测试

    lr = LinerRegression()
    lr.fit(x,y)
    
    print(lr.w, lr.b)
    # 1.3224310227553517 7.991020982270779
    
    print(lr.compute_loss(x,y))
    #110.25738346621318
    
    y_ = lr.predict(x) # 预测
    plt.scatter(x,y)
    plt.plot(x,y_,c='r')
    plt.show()

    展开全文
  • 机器学习中简单的非线性回归python代码,亲测有效。。
  • 目录1线性回归1.1简单线性回归1.2 多元线性回归1.3 使用sklearn中的线性回归模型 1线性回归 1.1简单线性回归 在简单线性回归中,通过调整a和b的参数值,来拟合从x到y的线性关系。下图为进行拟合所需要优化的目标,...

    1线性回归

    1.1简单线性回归

    在简单线性回归中,输入x只有一个特征,通过调整a和b的参数值,来拟合从x到y的线性关系。下图为进行拟合所需要优化的目标,也即是MES(Mean Squared Error),只不过省略了平均的部分(除以m)。

    对于简单线性回归,只有两个参数a和b,通过对MSE优化目标求导后取极值点极值(最小二乘法),即可求得最优a和b如下,所以在训练简单线性回归模型时,也只需要根据数据求解这两个参数值即可。

    下面使用波士顿房价数据集中,索引为5(第6个特征)的特征RM (average number of rooms per dwelling:每个住宅的平均房间数)来进行简单线性回归。其中使用的评价指标为:

    以及R方指标。这里R方指标一般情况下可以将对模型的评价压缩到[0,1]之间(也可能是负数),值越接近1效果越好。在式子分子分母中的两项都可以认作在算均方误差,只不过分子使用我们训练的线性回归模型的输出,分母则使用真实标签数据的平均值来做均方误差,表示对每个样本,都是一个固定值瞎猜结果,其值等价于实际标签值的方差。通过模型的均方误差和瞎猜产生的误差做对比,就可以将评价指标限定在[0,1](如果模型比瞎猜还差就会成为负数)。

    # 以sklearn的形式对simple linear regression 算法进行封装
    import numpy as np
    import sklearn.datasets as datasets
    from sklearn.model_selection import train_test_split
    import matplotlib.pyplot as plt
    from sklearn.metrics import mean_squared_error,mean_absolute_error
    np.random.seed(123)
    
    class SimpleLinearRegression():
        def __init__(self):
            """
            initialize model parameters
            """
            self.a_=None
            self.b_=None
    
        def fit(self,x_train,y_train):
            """
            training model parameters
    
            Parameters
            ----------
                x_train:train x ,shape:data [N,]
                y_train:train y ,shape:data [N,]
            """
            assert (x_train.ndim==1 and y_train.ndim==1),\
                """Simple Linear Regression model can only solve single feature training data"""
            assert len(x_train)==len(y_train),\
                """the size of x_train must be equal to y_train"""
    
            x_mean=np.mean(x_train)
            y_mean=np.mean(y_train)
            self.a_=np.vdot((x_train-x_mean),(y_train-y_mean))/np.vdot((x_train-x_mean),(x_train-x_mean))
            self.b_=y_mean-self.a_*x_mean
    
        def predict(self,input_x):
            """
            make predictions based on a batch of data
    
            Parameters
            ----------
                input_x:shape->[N,]
            """
            assert input_x.ndim==1 ,\
                """Simple Linear Regression model can only solve single feature data"""
    
            return np.array([self.pred_(x) for x in input_x])
    
        def pred_(self,x):
            """
            give a prediction based on single input x
            """
            return self.a_*x+self.b_
    
        def __repr__(self):
            return "SimpleLinearRegressionModel"
    
    if __name__ == '__main__':
        boston_data = datasets.load_boston()
        print(boston_data['DESCR'])
        x = boston_data['data'][:, 5]  # total x data (506,)
        y = boston_data['target']  # total y data (506,)
        # keep data with target value less than 50.
        x = x[y < 50]  # total x data (490,)
        y = y[y < 50]  # total x data (490,)
    
        plt.scatter(x, y)
        plt.show()
    
        # train size:(343,) test size:(147,)
        x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3)
    
        regs = SimpleLinearRegression()
        regs.fit(x_train, y_train)
        y_hat = regs.predict(x_test)
    
        rmse = np.sqrt(np.sum((y_hat - y_test) ** 2) / len(x_test))
        mse = mean_squared_error(y_test, y_hat)
        mae = mean_absolute_error(y_test, y_hat)
        # notice
        R_squared_Error = 1 - mse / np.var(y_test)
    
        print('mean squared error:%.2f' % (mse))
        print('root mean squared error:%.2f' % (rmse))
        print('mean absolute error:%.2f' % (mae))
        print('R squared Error:%.2f' % (R_squared_Error))
    
        a = regs.a_
        b = regs.b_
        x_plot = np.linspace(4, 8, 50)
        y_plot = x_plot * a + b
        plt.scatter(x, y)
        plt.plot(x_plot, y_plot, color='red')
        plt.show()
    

    输出结果:

    mean squared error:26.74
    root mean squared error:5.17
    mean absolute error:3.85
    R squared Error:0.50
    

    数据的可视化:

    1.2 多元线性回归的正规方程解

    多元线性回归中,单个x的样本拥有了多个特征,也就是上图中带下标的x。
    其结构可以用向量乘法表示出来:
    为了便于计算,一般会将x增加一个为1的特征,方便与截距bias计算。

    而多元线性回归的优化目标与简单线性回归一致。

    通过矩阵求导计算,可以得到方程解,但求解的时间复杂度很高。

    下面使用正规方程解的形式,来对波士顿房价的所有特征做多元线性回归。

    from math import sqrt
    import numpy as np
    #from PlayML.metrics import r2_score
    from sklearn.model_selection import train_test_split
    import sklearn.datasets as datasets
    #from PlayML.metrics import  root_mean_squared_error
    np.random.seed(123)
    
    
    def mean_squared_error(y_true, y_predict):
        """计算y_true和y_predict之间的MSE"""
        assert len(y_true) == len(y_predict), \
            "the size of y_true must be equal to the size of y_predict"
    
        return np.sum((y_true - y_predict)**2) / len(y_true)
    def r2_score(y_true, y_predict):
        """计算y_true和y_predict之间的R Square"""
        return 1 - mean_squared_error(y_true, y_predict)/np.var(y_true)
    
    def root_mean_squared_error(y_true, y_predict):
        """计算y_true和y_predict之间的RMSE"""
    
        return sqrt(mean_squared_error(y_true, y_predict))
    
    class LinearRegression():
        def __init__(self):
            self.coef_=None # coeffient
            self.intercept_=None # interception
            self.theta_=None
    
        def fit_normal(self, x_train, y_train):
            """
            use normal equation solution for multiple linear regresion as model parameters
    
            Parameters
            ----------
            theta=(X^T * X)^-1 * X^T * y
            """
            assert x_train.shape[0] == y_train.shape[0],\
                """size of the x_train must be equal to y_train """
            X_b=np.hstack([np.ones((len(x_train), 1)), x_train])
            self.theta_=np.linalg.inv(X_b.T.dot(X_b)).dot(X_b.T).dot(y_train) # (featere,1)
            self.coef_=self.theta_[1:]
            self.intercept_=self.theta_[0]
    
        def predict(self,x_pred):
            """给定待预测数据集X_predict,返回表示X_predict的结果向量"""
            assert self.intercept_ is not None and self.coef_ is not None, \
                "must fit before predict!"
            assert x_pred.shape[1] == len(self.coef_), \
                "the feature number of X_predict must be equal to X_train"
            X_b=np.hstack([np.ones((len(x_pred),1)),x_pred])
            return X_b.dot(self.theta_)
    
        def score(self,x_test,y_test):
            """
            Calculate evaluating indicator socre
    
            Parameters
            ---------
                x_test:x test data
                y_test:true label y for x test data
            """
            y_pred=self.predict(x_test)
            return r2_score(y_test,y_pred)
    
        def __repr__(self):
            return "LinearRegression"
    
    
    if __name__ == '__main__':
        # use boston house price dataset for test
        boston_data = datasets.load_boston()
        x = boston_data['data']  # total x data (506,)
        y = boston_data['target']  # total y data (506,)
        # keep data with target value less than 50.
        x = x[y < 50]  # total x data (490,)
        y = y[y < 50]  # total x data (490,)
        # train size:(343,) test size:(147,)
        x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3,random_state=123)
    
        regs = LinearRegression()
        regs.fit_normal(x_train, y_train)
    
        # calc error
        score=regs.score(x_test,y_test)
        rmse=root_mean_squared_error(y_test,regs.predict(x_test))
    
        print('R squared error:%.2f' % (score))
        print('Root mean squared error:%.2f' % (rmse))
    
    
    

    输出结果:

    R squared error:0.79
    Root mean squared error:3.36
    

    1.3 使用梯度下降求解多元线性回归

    使用梯度下降的方法,在数据比较多的情况下会比方程解快很多。代码也不难,只是关于参数梯度的向量化推导有一点复杂,还有就是训练前要先进行数据标准化。
    损失函数与之前相同,还是使用MSE损失。

    为了让梯度为列向量,再做依次转置,得到最终的结果。

    import numpy as np
    from math import sqrt
    import sklearn.datasets as datasets
    from sklearn.model_selection import train_test_split
    from sklearn.preprocessing import StandardScaler
    
    def accuracy_score(y_true, y_predict):
        """计算y_true和y_predict之间的准确率"""
        assert len(y_true) == len(y_predict), \
            "the size of y_true must be equal to the size of y_predict"
    
        return np.sum(y_true == y_predict) / len(y_true)
    
    
    def mean_squared_error(y_true, y_predict):
        """计算y_true和y_predict之间的MSE"""
        assert len(y_true) == len(y_predict), \
            "the size of y_true must be equal to the size of y_predict"
    
        return np.sum((y_true - y_predict)**2) / len(y_true)
    
    
    def root_mean_squared_error(y_true, y_predict):
        """计算y_true和y_predict之间的RMSE"""
    
        return sqrt(mean_squared_error(y_true, y_predict))
    
    
    def mean_absolute_error(y_true, y_predict):
        """计算y_true和y_predict之间的MAE"""
        assert len(y_true) == len(y_predict), \
            "the size of y_true must be equal to the size of y_predict"
    
        return np.sum(np.absolute(y_true - y_predict)) / len(y_true)
    
    
    def r2_score(y_true, y_predict):
        """计算y_true和y_predict之间的R Square"""
    
        return 1 - mean_squared_error(y_true, y_predict)/np.var(y_true)
    
    
    class LinearRegression:
    
        def __init__(self):
            """初始化Linear Regression模型"""
            self.coef_ = None
            self.intercept_ = None
            self._theta = None
    
        def fit_normal(self, X_train, y_train):
            """根据训练数据集X_train, y_train训练Linear Regression模型"""
            assert X_train.shape[0] == y_train.shape[0], \
                "the size of X_train must be equal to the size of y_train"
    
            X_b = np.hstack([np.ones((len(X_train), 1)), X_train])
            self._theta = np.linalg.inv(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):
            """根据训练数据集X_train, y_train, 使用梯度下降法训练Linear Regression模型"""
            assert X_train.shape[0] == y_train.shape[0], \
                "the size of X_train must be equal to the size of y_train"
    
            def J(theta, X_b, y):
                try:
                    return np.sum((y - X_b.dot(theta)) ** 2) / len(y)
                except:
                    return float('inf')
                
            def dJ(theta, X_b, y):
                return X_b.T.dot(X_b.dot(theta) - y) * 2. / len(y)
    
            def gradient_descent(X_b, y, initial_theta, eta, n_iters=1e4, epsilon=1e-8):
    
                theta = initial_theta
                cur_iter = 0
    
                while cur_iter < n_iters:
                    gradient = dJ(theta, X_b, y)
                    last_theta = theta
                    theta = theta - eta * gradient
                    if (abs(J(theta, X_b, y) - J(last_theta, X_b, y)) < epsilon):
                        break
    
                    cur_iter += 1
    
                return theta
    
            X_b = np.hstack([np.ones((len(X_train), 1)), X_train])
            initial_theta = np.zeros(X_b.shape[1])
            self._theta = gradient_descent(X_b, y_train, initial_theta, eta, n_iters)
    
            self.intercept_ = self._theta[0]
            self.coef_ = self._theta[1:]
    
            return self
    
        def predict(self, X_predict):
            """给定待预测数据集X_predict,返回表示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.hstack([np.ones((len(X_predict), 1)), X_predict])
            return X_b.dot(self._theta)
    
        def score(self, X_test, y_test):
            """根据测试数据集 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__':
        # use boston house price dataset
        boston_data = datasets.load_boston()
        x = boston_data['data']  # total x size (506,)
        y = boston_data['target']  # total y size (506,)
        # keep data with target value less than 50.
        x = x[y < 50]  # total x size (490,)
        y = y[y < 50]  # total x size (490,)
    
        # notice! need data normalize
        scaler=StandardScaler().fit(x)
        x=scaler.transform(x)
    
        # train size:(343,) test size:(147,)
        x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=123)
    
        regs = LinearRegression()
        regs.fit_gd(x_train, y_train)
    
        # calc error
        score = regs.score(x_test, y_test)
        rmse = root_mean_squared_error(y_test, regs.predict(x_test))
    
        print('R squared error:%.2f' % (score))
        print('Root mean squared error:%.2f' % (rmse))
    
        print('coeffient:', regs.coef_.shape)
        print('interception:', regs.intercept_.shape)
    

    1.4 sklearn中的线性回归模型

    import sklearn.datasets as datasets
    from sklearn.linear_model import LinearRegression
    import numpy as np
    from sklearn.model_selection import train_test_split
    from math import sqrt
    np.random.seed(123)
    
    def mean_squared_error(y_true, y_predict):
        """计算y_true和y_predict之间的MSE"""
        assert len(y_true) == len(y_predict), \
            "the size of y_true must be equal to the size of y_predict"
    
        return np.sum((y_true - y_predict)**2) / len(y_true)
    
    def root_mean_squared_error(y_true, y_predict):
        """计算y_true和y_predict之间的RMSE"""
        return sqrt(mean_squared_error(y_true, y_predict))
    
    if __name__ == '__main__':
        # use boston house price dataset
        boston_data = datasets.load_boston()
        x = boston_data['data']  # total x size (506,)
        y = boston_data['target']  # total y size (506,)
        # keep data with target value less than 50.
        x = x[y < 50]  # total x size (490,)
        y = y[y < 50]  # total x size (490,)
        # train size:(343,) test size:(147,)
        x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=123)
    
        regs = LinearRegression()
        regs.fit(x_train, y_train)
    
        # calc error
        score = regs.score(x_test, y_test)
        rmse = root_mean_squared_error(y_test, regs.predict(x_test))
    
        print('R squared error:%.2f' % (score))
        print('Root mean squared error:%.2f' % (rmse))
    
        print('coeffient:',regs.coef_.shape)
        print('interception:',regs.intercept_.shape)
    
    R squared error:0.79
    Root mean squared error:3.36
    coeffient: (13,)
    interception: ()
    
    展开全文
  • 今天小编就为大家分享一篇sklearn+python:线性回归案例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 简单线性回归python实现、多元统计分析

    因变量Y(或Y1 , …,Yp )与x1 ,x2 ,…,xm的回归方程:

    Y=f(x_{1},x_{2},...,x_{m})=a_{0}+a_{1}x_{1}+a_{2}x_{2}+...+a_{m}x_{m}+\varepsilon

    数据导入与清洗

    import pandas as pd
    import numpy as np
    import matplotlib.pyplot as plt
    from sklearn.model_selection import train_test_split
    from sklearn.linear_model import LinearRegression
    
    pd_data = pd.read_csv("xxxx.csv")   #可用read_csv导入数据
    
    

    利用numpy和pandas对数据进行操作

    利用matplotlib将数据图像化

    利用sklearn导入数据集训练和模型

    多元线性回归

    
    #清洗不需要的数据
    new_pd_data = pd_data.ix[:,1:]
    #数据描述
    print(new_pd_data.describe())
    #缺失值检验
    print(new_pd_data[new_pd_data.isnull()==True].count())
    
    
    
    #R方检测
    #决定系数r平方
    #对于评估模型的精确度
    #y误差平方和 = Σ(y实际值 - y预测值)^2
    #y的总波动 = Σ(y实际值 - y平均值)^2
    #有多少百分比的y波动没有被回归拟合线所描述 = SSE/总波动
    #有多少百分比的y波动被回归线描述 = 1 - SSE/总波动 = 决定系数R平方
    #对于决定系数R平方来说
    #1) 回归线拟合程度:有多少百分比的y波动刻印有回归线来描述(x的波动变化)
    #2)值大小:R平方越高,回归模型越精确(取值范围0~1),1无误差,0无法完成拟合
    

     数据清洗、预测等与简单线性回归类似

    简单线性回归

    创建简单模型

    in

    #创建数据集
    examDict  = {'worktime':[0.50,0.75,1.00,1.25,1.50,1.75,1.75,2.00,2.25,2.50,2.75,3.00,3.25,3.50,4.00,4.25,4.50,4.75,5.00,5.50],
                 'output':[10,22,13,43,20,22,33,50,62,48,55,75,62,73,81,76,64,82,90,93]}
     
    #转换为DataFrame的数据格式
    examDF = pd.DataFrame(examDict)
    

    out

      worktime  output
    0       0.50      10
    1       0.75      22
    2       1.00      13
    3       1.25      43
    4       1.50      20
    5       1.75      22
    6       1.75      33
    7       2.00      50
    8       2.25      62
    9       2.50      48
    10      2.75      55
    11      3.00      75
    12      3.25      62
    13      3.50      73
    14      4.00      81
    15      4.25      76
    16      4.50      64
    17      4.75      82
    18      5.00      90
    19      5.50      93

     图像化

    in

    #绘制散点图
    plt.scatter(examDF.worktime,examDF.output,color = 'g',label = "Exam Data")
     
    #添加图的标签(x轴,y轴)
    plt.xlabel("worktime")
    plt.ylabel("output")
    
    #显示图像
    plt.show()

    out

     pandas中可反应数据间相关性的函数obj.corr()       (参数为空时,默认使用的参数为pearson)

    corr( )有三种用法:

    1.pearson:衡量两个数据集合是否在一条线上面

                       即针对线性数据的相关系数计算,针对非线性数据便会有误差。

    2.spearman:非线性的,非正态分析的数据的相关系数

    3.kendall:用于反映分类变量相关性的指标,即针对无序序列的相关系数,非正态分布的数据

    in

    rDF = examDF.corr(method = "pearson")
    print(rDF)

    out 

                         worktime    output
    worktime     1.000000     0.923985
    output          0.923985     1.000000

    划分训练集和测试集

    in

    #划分x,y
    exam_X=examDF[["worktime"]] 
    exam_Y= examDF[["output"]]
    
    
    #将原数据集拆分训练集和测试集
    X_train,X_test,Y_train,Y_test = train_test_split(exam_X,exam_Y,train_size=.8)
    #X_train为训练数据,X_test为测试数据,exam_X为样本特征,exam_y为样本标签,train_size 训练数据占比
    
    
    # print("原始数据特征:",exam_X.shape,
    #       ",训练数据特征:",X_train.shape,
    #       ",测试数据特征:",X_test.shape)
     
    # print("原始数据标签:",exam_Y.shape,
    #       ",训练数据标签:",Y_train.shape,
    #       ",测试数据标签:",Y_test.shape)
        
    
    
    
    #线性回归模型
    model = LinearRegression()            #线性回归模型
    model.fit(X_train,Y_train)            #模型的成员函数fit(X,y)以数组X和y为输入
    a = model.intercept_                       #截距   判断是否有截据,如果没有则直线过原点
    b = model.coef_                            #回归系数   模型的成员变量,存储线性模型的系数
    #训练数据预测值
    y_train_pred = model.predict(X_train)       #预测
    score = model.score(X_test,Y_test)         #可决系数   返回对于以X为samples,以y为target的预测效果评分
    
    

     out

    截距: [9.19829213]
    回归系数: [[15.80379307]]
    预测: [[48.55501931]
     [31.77509653]
     [44.36003861]
     [35.97007722]
     [23.38513514]
     [90.50482625]
     [82.11486486]
     [65.33494208]
     [56.94498069]
     [61.13996139]
     [73.72490347]
     [35.97007722]
     [14.99517375]
     [52.75      ]
     [98.89478764]
     [27.58011583]]
    评分: 0.6983823980938839

    原始数据特征: (20, 1) ,训练数据特征: (16, 1) ,测试数据特征: (4, 1)
    原始数据标签: (20, 1) ,训练数据标签: (16, 1) ,测试数据标签: (4, 1)

    train_test_split函数
    train_test_split(train_data,train_target,test_size=0.4, random_state=0,stratify=y_train)

    train_data:所要划分的样本特征集

    train_target:所要划分的样本结果

                      ①若为浮点时,表示训练集占总样本的百分比

                     ②若为整数时,表示训练样本的样本数

                     ③若为None时,train_size自动被设置成0.75

    test_size:样本占比(可以为浮点、整数或None,默认为None)

                     ①为浮点,表示测试集占总样本的百分比

                     ②为整数,表示测试样本的样本数

                     ③为None,test_size自动设置成0.25

    random_state:随机数种子(该组随机数的编号,在需要重复试验的时候,保证得到一组

                           一样的随机数,比如填1,在其他参数一样的情况下所得随机数组是一样的)  

    stratify:保持split前类的分布,=X就是按照X中的比例分配 ,=y就是按照y中的比例分配 

    为None,划分出来的测试集或训练集中,其类标签的比例是随机的

    不为None,划分出来的测试集或训练集中,其类标签的比例同输入的数组中类标签的比例相同,可以用于处理不均衡的数据集

    train-test散点图

    in

     
    #散点图
    plt.scatter(X_train, Y_train, color="blue", label="train data")
    plt.scatter(X_test, Y_test, color="yellow", label="test data")
     
    #添加图标标签
    plt.legend(loc=2)
    plt.xlabel("Hours")
    plt.ylabel("Pass")
    #显示图像
    plt.show()

    out 

    最佳拟合线+测试数据散点图

    in

    #绘制最佳拟合线:标签用的是训练数据的预测值y_train_pred
    plt.plot(X_train, y_train_pred, color='black', linewidth=3, label="best line")
     
    #测试数据散点图
    plt.scatter(X_test, Y_test, color='red', label="test data")
    plt.scatter(X_train, Y_train, color='green', label="train data")
    #添加图标标签
    plt.legend(loc=2)
    plt.xlabel("worktime")
    plt.ylabel("output")
    #显示图像
    plt.show()

    out 

     

     

     

    展开全文
  • 线性回归python版本

    2021-09-14 18:09:29
    线性回归
  • 主要介绍了Python利用神经网络解决非线性回归问题,结合实例形式详细分析了Python使用神经网络解决非线性回归问题的相关原理与实现技巧,需要的朋友可以参考下
  • 线性回归python源码

    2018-08-24 17:04:08
    线性回归python代码实例,数据集较小,准确率仍然能达到80%。
  • 线性回归python demo

    2019-01-24 14:23:00
    machine learning的小作业,一个简单的线性回归的demo,喜欢的请下载
  • 今天小编就为大家分享一篇python实现简单的单变量线性回归方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 线性回归Python实现(ipynb文件).zip
  • python 机器学习的代码
  • python一元线性回归

    2022-05-02 21:35:51
    python一元线性回归
  • 可详细参考博主文章《【机器学习+sklearn框架】(一) 线性模型之Linear Regression》的公式推导,结合代码进行学习。
  • 使用Python进行简单线性回归在ML算法中,我们有: 监督学习无监督学习在监督学习中,我们有: 回归分类首先,我们讨论不同类型的回归。 线性回归简单线性回归多元线性回归逻辑回归套索回归岭回归在此存储库中,我们...
  • Advertising-线性回归测试数据集 投放广告与收入线性样本 数据为: 电视广告 广播广告 报纸广告 收入 是学习线性回归测试必备数据集
  • 一元线性回归Python

    千次阅读 2022-07-02 22:37:48
    一元线性回归原理以及Python实现例子
  • 通过对可能影响处理耗时的各个特征数据及其耗时进行多元线性回归训练,后根据待预测特征数据来估计耗时
  • 本课程主要讲述如何使用python进行线性回归与非线性回归分析,包括: 基于statsmodel的线性回归方法基于sklearn的线性回归方法基于Numpy的一元多项式非线性回归方法基于sklearn的多元多项式非线性回归方法基于scipy...
  • 人工智能机器学习入门,minist线性回归,图像识别预测分类
  • 机器学习中线性回归以及岭回归算法的实现,Python版本
  • PySpark线性回归

    2020-09-06 22:44:20
    利用Python调用spark接口训练线性回归模型,详细介绍了PySpark的使用,包含:数据准备、数据探索、特征工程和模型训练
  • 机器学习之线性回归python实现

    千次阅读 2017-09-14 15:03:28
    线性回归 岭回归 lasso回归 局部加权线性回归python实现 代码 结果 数据 一. 理论基础1. 线性回归损失函数: L(w)=12M∑i=1m(y−xiw)2L(w) = \frac{1}{2M}\sum_{i=1}^{m}{(y - x_iw)^2} 闭式解:W=(XTX)−1...
  • 利用python实现多元线性回归

    千次阅读 2022-05-19 10:33:13
    多元线性回归分析

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 88,287
精华内容 35,314
关键字:

线性回归python

友情链接: UART.zip