精华内容
下载资源
问答
  • 主要介绍了Python利用逻辑回归模型解决MNIST手写数字识别问题,结合实例形式详细分析了Python MNIST手写识别问题原理及逻辑回归模型解决MNIST手写识别问题相关操作技巧,需要的朋友可以参考下
  • 主要介绍了Python利用神经网络解决非线性回归问题,结合实例形式详细分析了Python使用神经网络解决非线性回归问题的相关原理与实现技巧,需要的朋友可以参考下
  • 利用神经网络解决非线性回归问题

    千次阅读 2018-12-15 15:59:09
    现在我们通常使用神经网络进行分类,但是有时我们也会进行回归分析。 如本文的问题: 我们知道一个生物体内的原始有毒物质的量,然后对这个生物体进行治疗,向其体内注射一个物质,过一段时间后重新测量这个生物体内...

    问题描述

    现在我们通常使用神经网络进行分类,但是有时我们也会进行回归分析。
    如本文的问题:
    我们知道一个生物体内的原始有毒物质的量,然后对这个生物体进行治疗,向其体内注射一个物质,过一段时间后重新测量这个生物体内有毒物质量的多少。
    因此,问题中有两个输入,都是标量数据,分别为有毒物质的量和注射物质的量,一个输出,也就是注射治疗物质后一段时间生物体的有毒物质的量。
    数据如下图:
    在这里插入图片描述
    其中Dose of Mycotoxins 就是有毒物质,Dose of QCT就是治疗的药物。
    其中蓝色底纹的数字就是输出结果。

    一些说明

    由于本文是进行回归分析,所以最后一层不进行激活,而直接输出。
    本文程序使用sigmoid函数进行激活。
    本文程序要求程序有一定的可重复性,隐含层可以指定。

    另外,注意到
    本文将使用数据预处理,也就是将数据减去均值再除以方差,否则使用sigmoid将会导致梯度消失。
    因为数据比较大,比如200,这时输入200,当sigmoid函数的梯度就是接近于0了。
    与此同时,我们在每一次激活前都进行BN处理,也就是batch normalize,中文可以翻译成规范化。
    否则也会导致梯度消失的问题。与预处理情况相同。

    程序

    程序包括两部分,一部分是模型框架,一个是训练模型

    第一部分:

    # coding=utf-8
    import numpy as np
    
    
    def basic_forard(x, w, b):
        x = x.reshape(x.shape[0], -1)
        out = np.dot(x, w) + b
        cache = (x, w, b)
    
        return out, cache
    
    
    def basic_backward(dout, cache):
        x, w, b = cache
        dout = np.array(dout)
        dx = np.dot(dout, w.T)
        # dx = np.reshape(dx, x.shape)
        # x = x.reshape(x.shape[0], -1)
        dw = np.dot(x.T, dout)
        db = np.reshape(np.sum(dout, axis=0), b.shape)
    
        return dx, dw, db
    
    
    def batchnorm_forward(x, gamma, beta, bn_param):
    
        mode = bn_param['mode']
        eps = bn_param.get('eps', 1e-5)
        momentum = bn_param.get('momentum', 0.9)
    
        N, D = x.shape
        running_mean = bn_param.get('running_mean', np.zeros(D, dtype=x.dtype))
        running_var = bn_param.get('running_var', np.zeros(D, dtype=x.dtype))
    
        out, cache = None, None
        if mode == 'train':
            sample_mean = np.mean(x, axis=0)
            sample_var = np.var(x, axis=0)
            x_hat = (x - sample_mean) / (np.sqrt(sample_var + eps))
            out = gamma * x_hat + beta
            cache = (gamma, x, sample_mean, sample_var, eps, x_hat)
            running_mean = momentum * running_mean + (1 - momentum) * sample_mean
            running_var = momentum * running_var + (1 - momentum) * sample_var
    
        elif mode == 'test':
            scale = gamma / (np.sqrt(running_var + eps))
            out = x * scale + (beta - running_mean * scale)
    
        else:
            raise ValueError('Invalid forward batchnorm mode "%s"' % mode)
    
    
        bn_param['running_mean'] = running_mean
        bn_param['running_var'] = running_var
    
        return out, cache
    
    
    def batchnorm_backward(dout, cache):
        gamma, x, u_b, sigma_squared_b, eps, x_hat = cache
        N = x.shape[0]
    
        dx_1 = gamma * dout
        dx_2_b = np.sum((x - u_b) * dx_1, axis=0)
        dx_2_a = ((sigma_squared_b + eps) ** -0.5) * dx_1
        dx_3_b = (-0.5) * ((sigma_squared_b + eps) ** -1.5) * dx_2_b
        dx_4_b = dx_3_b * 1
        dx_5_b = np.ones_like(x) / N * dx_4_b
        dx_6_b = 2 * (x - u_b) * dx_5_b
        dx_7_a = dx_6_b * 1 + dx_2_a * 1
        dx_7_b = dx_6_b * 1 + dx_2_a * 1
        dx_8_b = -1 * np.sum(dx_7_b, axis=0)
        dx_9_b = np.ones_like(x) / N * dx_8_b
        dx_10 = dx_9_b + dx_7_a
    
        dgamma = np.sum(x_hat * dout, axis=0)
        dbeta = np.sum(dout, axis=0)
        dx = dx_10
    
        return dx, dgamma, dbeta
    
    
    # def relu_forward(x):
    #     out = None
    #     out = np.maximum(0,x)
    #     cache = x
    #     return out, cache
    #
    #
    # def relu_backward(dout, cache):
    #     dx, x = None, cache
    #     dx = (x >= 0) * dout
    #     return dx
    
    
    def sigmoid_forward(x):
        x = x.reshape(x.shape[0], -1)
        out = 1 / (1 + np.exp(-1 * x))
        cache = out
    
        return out, cache
    
    
    def sigmoid_backward(dout, cache):
        out = cache
        dx = out * (1 - out)
        dx *= dout
    
        return dx
    
    
    def basic_sigmoid_forward(x, w, b):
        basic_out, basic_cache = basic_forard(x, w, b)
        sigmoid_out, sigmoid_cache = sigmoid_forward(basic_out)
        cache = (basic_cache, sigmoid_cache)
    
        return sigmoid_out, cache
    
    
    # def basic_relu_forward(x, w, b):
    #     basic_out, basic_cache = basic_forard(x, w, b)
    #     relu_out, relu_cache = relu_forward(basic_out)
    #     cache = (basic_cache, relu_cache)
    #
    #     return relu_out, cache
    
    
    def basic_sigmoid_backward(dout, cache):
        basic_cache, sigmoid_cache = cache
        dx_sigmoid = sigmoid_backward(dout, sigmoid_cache)
        dx, dw, db = basic_backward(dx_sigmoid, basic_cache)
    
        return dx, dw, db
    
    # def basic_relu_backward(dout, cache):
    #     basic_cache, relu_cache = cache
    #     dx_relu = relu_backward(dout, relu_cache)
    #     dx, dw, db = basic_backward(dx_relu, basic_cache)
    #
    #     return dx, dw, db
    
    
    def mean_square_error(x, y):
        x = np.ravel(x)
        loss = 0.5 * np.sum(np.square(y - x)) / x.shape[0]
        dx = (x - y).reshape(-1, 1)
        return loss, dx
    
    class muliti_layer_net(object):
        def __init__(self, hidden_dim, input_dim=2, num_classes=2, weight_scale=0.01, dtype=np.float32, seed=None, reg=0.0, use_batchnorm=True):
            self.num_layers = 1 + len(hidden_dim)
            self.dtype = dtype
            self.reg = reg
            self.params = {}
            self.weight_scale = weight_scale
            self.use_batchnorm = use_batchnorm
    
            # init all parameters
            layers_dims = [input_dim] + hidden_dim + [num_classes]
    
            for i in range(self.num_layers):
                self.params['W' + str(i + 1)] = np.random.randn(layers_dims[i], layers_dims[i + 1]) * self.weight_scale
                self.params['b' + str(i + 1)] = np.zeros((1, layers_dims[i + 1]))
                if self.use_batchnorm and i < (self.num_layers - 1):
                    self.params['gamma' + str(i + 1)] = np.ones((1, layers_dims[i + 1]))
                    self.params['beta' + str(i + 1)] = np.zeros((1, layers_dims[i + 1]))
    
            self.bn_params = []  # list
            if self.use_batchnorm:
                self.bn_params = [{'mode': 'train'} for i in range(self.num_layers - 1)]
    
    
        def loss(self, X, y=None):
            X = X.astype(self.dtype)
            mode = 'test' if y is None else 'train'
    
            # compute the forward data and cache
            basic_sigmoid_cache = {}
            layer_out = {}
            layer_out[0] = X
            out_basic_forward, cache_basic_forward = {}, {}
            out_bn, cache_bn = {}, {}
            out_sigmoid_forward, cache_sigmoid_forward = {}, {}
    
            for lay in range(self.num_layers - 1):
                # print('lay: %f' % lay)
                W = self.params['W' + str(lay + 1)]
                b = self.params['b' + str(lay + 1)]
                if self.use_batchnorm:
                    gamma, beta = self.params['gamma' + str(lay + 1)], self.params['beta' + str(lay + 1)]
                    out_basic_forward[lay], cache_basic_forward[lay] = basic_forard(np.array(layer_out[lay]), W, b)
                    out_bn[lay], cache_bn[lay] = batchnorm_forward(np.array(out_basic_forward[lay]), gamma, beta, self.bn_params[lay])
                    layer_out[lay + 1], cache_sigmoid_forward[lay] = sigmoid_forward(np.array(out_bn[lay]))
                     # = out_sigmoid_forward[lay]
                else:
                    layer_out[lay+1], basic_sigmoid_cache[lay] = basic_sigmoid_forward(layer_out[lay], W, b)
    
            score, basic_cache = basic_forard(layer_out[self.num_layers-1], self.params['W' + str(self.num_layers)], self.params['b' + str(self.num_layers)])
            # print('Congratulations: Loss is computed successfully!')
    
            if mode == 'test':
                return score
    
            # compute the gradient
            grads = {}
    
            loss, dscore = mean_square_error(score, y)
            dx, dw, db = basic_backward(dscore, basic_cache)
            grads['W' + str(self.num_layers)] = dw + self.reg * self.params['W' + str(self.num_layers)]
            grads['b' + str(self.num_layers)] = db
            loss += 0.5 * self.reg * np.sum(self.params['W' + str(self.num_layers)] * self.params['b' + str(self.num_layers)])
    
            dbn, dsigmoid = {}, {}
    
            for index in range(self.num_layers - 1):
                lay = self.num_layers - 1 - index - 1
                loss += 0.5 * self.reg * np.sum(self.params['W' + str(lay + 1)] * self.params['b' + str(lay + 1)])
                if self.use_batchnorm:
                    dsigmoid[lay] = sigmoid_backward(dx, cache_sigmoid_forward[lay])
                    dbn[lay], grads['gamma' + str(lay + 1)], grads['beta' + str(lay + 1)] = batchnorm_backward(dsigmoid[lay], cache_bn[lay])
                    dx, grads['W' + str(lay + 1)], grads['b' + str(lay + 1)] = basic_backward(dbn[lay], cache_basic_forward[lay])
    
                else:
                    dx, dw, db = basic_sigmoid_backward(dx, basic_sigmoid_cache[lay])
    
            for lay in range(self.num_layers):
                grads['W' + str(lay + 1)] += self.reg * self.params['W' + str(lay + 1)]
    
            return loss, grads
    
    
    def sgd_momentum(w, dw, config=None):
        if config is None: config = {}
        config.setdefault('learning_rate', 1e-2)
        config.setdefault('momentum', 0.9)
        v = config.get('velocity', np.zeros_like(w))
        v = config['momentum'] * v - config['learning_rate'] * dw
        next_w = w + v
        config['velocity'] = v
        return next_w, config
    
    
    class Solver(object):
    
        def __init__(self, model, data, **kwargs):
            self.model = model
            self.X_train = data['X_train']
            self.y_train = data['y_train']
            self.X_val = data['X_val']
            self.y_val = data['y_val']
    
            self.update_rule = kwargs.pop('update_rule', 'sgd_momentum')
            self.optim_config = kwargs.pop('optim_config', {})
            self.lr_decay = kwargs.pop('lr_decay', 1.0)
            self.batch_size = kwargs.pop('batch_size', 100)
            self.num_epochs = kwargs.pop('num_epochs', 10)
            self.weight_scale = kwargs.pop('weight_scale', 0.01)
    
            self.print_every = kwargs.pop('print_every', 10)
            self.verbose = kwargs.pop('verbose', True)
    
            if len(kwargs) > 0:
                extra = ', '.join('"%s"' % k for k in kwargs.keys())
                raise ValueError('Unrecognized argements %s' % extra)
    
            self._reset()
    
        def _reset(self):
            self.epoch = 100
            self.best_val_acc = 0
            self.best_params = {}
            self.loss_history = []
            self.train_acc_history = []
            self.val_acc_history = []
    
            self.optim_configs = {}
            for p in self.model.params:
                d = {k: v for k, v in self.optim_config.items()}
                self.optim_configs[p] = d
    
        def _step(self):
            loss, grads = self.model.loss(self.X_train, self.y_train)
            self.loss_history.append(loss)
            for p, w in self.model.params.items():
                dw = grads[p]
                config = self.optim_configs[p]
                next_w, next_config = sgd_momentum(w, dw, config)
                self.model.params[p] = next_w
                self.optim_configs[p] = next_config
            return loss
    
        def train(self):
            min_loss = 100000000
            num_train = self.X_train.shape[0]
            iterations_per_epoch = max(num_train / self.batch_size, 1)
            num_iterations = self.num_epochs * iterations_per_epoch
    
            for t in range(int(num_iterations)):
                loss = self._step()
    
                if self.verbose:
    #                 print(self.loss_history[-1])
                    pass
    
                if loss < min_loss:
                    min_loss = loss
                    for k, v in self.model.params.items():
                        self.best_params[k] = v.copy()
    
            self.model.params = self.best_params
    

    第二部分

    import numpy as np
    
    # import data
    
    dose_QCT = np.array([0, 5, 10, 20])
    mean_QCT, std_QCT = np.mean(dose_QCT), np.std(dose_QCT)
    dose_QCT = (dose_QCT - mean_QCT ) / std_QCT
    
    dose_toxins = np.array([0, 0.78125, 1.5625, 3.125, 6.25, 12.5, 25, 50, 100, 200])
    mean_toxins, std_toxins = np.mean(dose_toxins), np.std(dose_toxins)
    dose_toxins = (dose_toxins - mean_toxins ) / std_toxins
    
    result = np.array([[0, 4.037, 7.148, 12.442, 18.547, 25.711, 34.773, 62.960, 73.363, 77.878],
                       [0, 2.552, 4.725, 8.745, 14.436, 21.066, 29.509, 55.722, 65.976, 72.426],
                       [0, 1.207, 2.252, 4.037, 7.148, 11.442, 17.136, 34.121, 48.016, 60.865],
                       [0, 0.663, 1.207, 2.157, 3.601, 5.615, 8.251, 19.558, 33.847, 45.154]])
    mean_result, std_result = np.mean(result), np.std(result)
    result = (result - mean_result ) / std_result
    
    # create the train data
    train_x, train_y = [], []
    for i,qct in enumerate(dose_QCT):
        for j,toxin in enumerate(dose_toxins):
            x = [qct, toxin]
            y = result[i, j]
            train_x.append(x)
            train_y.append(y)
    
    train_x = np.array(train_x)
    train_y = np.array(train_y)
    
    print(train_x.shape)
    print(train_y.shape)
    
    import layers_regression
    small_data = {'X_train': train_x,
                  'y_train': train_y,
                  'X_val': train_x,
                  'y_val': train_y,}
    
    batch_size = train_x.shape[0]
    learning_rate = 0.002
    reg = 0
    
    model = layers_regression.muliti_layer_net(hidden_dim=[5,5], input_dim=2, num_classes=1, reg=reg, dtype=np.float64)
    
    solver = layers_regression.Solver(model, small_data, print_every=0, num_epochs=50000, batch_size=batch_size, weight_scale=1,
                                      update_rule='sgd_momentum', optim_config={'learning_rate': learning_rate})
    print('Please wait several minutes!')
    solver.train()
    # print(model.params)
    best_model = model
    
    print('Train process is finised')
    
    import matplotlib.pyplot as plt
    # %matplotlib inline
    plt.plot(solver.loss_history, '.')
    plt.title('Training loss history')
    plt.xlabel('Iteration')
    plt.ylabel('Training loss')
    plt.show()
    
    # predict the training_data
    
    predict = best_model.loss(train_x)
    predict = np.round(predict * std_result + mean_result, 1)
    print('Predict is ')
    print('{}'.format(predict.reshape(4, 10)))
    # print('{}'.format(predict))
    
    # observe the error between the predict after training with ground truth
    
    result = np.array([[0, 4.037, 7.148, 12.442, 18.547, 25.711, 34.773, 62.960, 73.363, 77.878],
                       [0, 2.552, 4.725, 8.745, 14.436, 21.066, 29.509, 55.722, 65.976, 72.426],
                       [0, 1.207, 2.252, 4.037, 7.148, 11.442, 17.136, 34.121, 48.016, 60.865],
                       [0, 0.663, 1.207, 2.157, 3.601, 5.615, 8.251, 19.558, 33.847, 45.154]])
    result = result.reshape(4, 10)
    
    predict = predict.reshape(4, 10)
    
    error = np.round(result - predict, 2)
    print('error between predict and real data')
    print(error)
    
    print('The absulate error in all data is %f' % np.sum(np.abs(error)))
    print('The mean error in all data is %f' % np.mean(np.abs(error)))
    
    
    # figure the predict map in 3D
    x_1 = (np.arange(0, 20, 0.1) - mean_QCT) / std_QCT
    x_2 = (np.arange(0, 200, 1) - mean_toxins) / std_toxins
    x_test = np.zeros((len(x_1)*len(x_2), 2))
    
    index = 0
    for i in range(len(x_1)):
        for j in range(len(x_2)):
            x_test[int(index), 0] = x_1[int(i)]
            x_test[int(index), 1] = x_2[int(j)]
            index += 1
            
    test_pred = best_model.loss(x_test)
    predict = np.round(test_pred * std_result + mean_result, 3)
    
    from mpl_toolkits.mplot3d import Axes3D
    
    x_1, x_2 = np.meshgrid(x_1 * std_QCT + mean_QCT, x_2 * std_toxins + mean_toxins)
    figure = plt.figure()
    ax = Axes3D(figure)
    predict = predict.reshape(len(x_1), len(x_2))
    ax.plot_surface(x_1, x_2, predict, rstride=1, cstride=1, cmap='rainbow')
    plt.show()
    
    # 最后本文将进行一些预测,但预测效果不是很好
    # question 2: predict with given
    dose_QCT_predict = np.ravel(np.array([7.5, 15]))
    dose_QCT_predict_ = (dose_QCT_predict - mean_QCT)/ std_QCT
    
    dose_toxins_predict = np.array([0, 0.78125, 1.5625, 3.125, 6.25, 12.5, 25, 50, 100, 200])
    dose_toxins_predict_ = (dose_toxins_predict - mean_toxins) / std_toxins
    
    test = []
    for i,qct in enumerate(dose_QCT_predict):
        for j,toxin in enumerate(dose_toxins_predict):
            x = [qct, toxin]
            test.append(x)
    test = np.array(test)
    print('Please look at the test data:')
    print(test)
    
    test = []
    for i,qct in enumerate(dose_QCT_predict_):
        for j,toxin in enumerate(dose_toxins_predict_):
            x = [qct, toxin]
            test.append(x)
            
    test = np.array(test)
    
    
    test_pred = best_model.loss(test)
    predict = np.round(test_pred * std_result + mean_result, 1)
    print(predict.reshape(2, 10))
    
    展开全文
  • sklearn解决回归问题

    2020-04-29 15:19:58
    这里只是大致统计一下利用sklearn做回归的方法选择, 后续进行案例分析。 方法: # 线性回归 from sklearn.linear_model import LinearRegression linear_regression = LinearRegression() # 决策树回归 from ...

    这里只是大致统计一下利用sklearn做回归的方法选择, 后续进行案例分析。

    方法:

    # 线性回归
    from sklearn.linear_model import LinearRegression
    linear_regression = LinearRegression()
    
    # 决策树回归
    from sklearn import tree
    decision_tree_regression = tree.DecisionTreeRegressor()
    
    # 支持向量机回归
    from sklearn import svm
    svm = svm.SVR()
    
    # K近邻回归
    from sklearn import neighbors
    k_neighbor = neighbors.KNeighborsRegressor()
    
    # 随机森林回归
    from sklearn import ensemble
    random_forest_regressor = ensemble.RandomForestRegressor(n_estimators=20) 
    
    # Adaboost回归
    from sklearn import ensemble
    adaboost_regressor = ensemble.AdaBoostRegressor(n_estimators=50)
    
    # GBRT回归
    from sklearn import ensemble
    gradient_boosting_regressor = ensemble.GradientBoostingRegressor(n_estimators=100) 
    
    # Bagging回归
    from sklearn import ensemble
    bagging_regressor = ensemble.BaggingRegressor()
    
    # ExtraTree极端随机数回归
    from sklearn.tree import ExtraTreeRegressor
    extra_tree_regressor = ExtraTreeRegressor()

     

    展开全文
  • 应用回归分析

    2019-09-12 14:10:20
    如何利用回归分析方法解决实际问题? 章节目录 回归分析概述 一元线性回归 多元线性回归(从第二章到第三章很多结论可以平推) 违背基本假定的情况(上面说的第三个问题) 自变量选择和逐步回归(模型选择) 多重...

    几个问题

    • 线性回归模型的思想和基本假设是什么?
    • 线性回归模型的估计与检验问题?模型中参数的估计和性质(检验)
    • 模型假设不符合时该如何处理?换模型换假定还是换指标设计?
    • 如何利用回归分析方法解决实际问题?

    章节目录

    • 回归分析概述
    • 一元线性回归
    • 多元线性回归(从第二章到第三章很多结论可以平推)
    • 违背基本假定的情况(上面说的第三个问题)
    • 自变量选择和逐步回归(模型选择)
    • 多重共线性的情形及其处理
    • 岭回归
    • 非线性回归(不是重点——书里还是退化到线性来解决,比较简单)
    • 含定性变量的回归模型(分类变量的处理)

    考核方式

    • 作业 30%
    • 课堂表现 10%
    • 闭卷考试 60%——选择题的部分(不定项选择40分)
    • 大作业(MSE)——预测书的价格

    第一章 回归分析概述

    变量间的统计关系

    • 先了解一下函数关系:确定的映射关系
    • 需要研究的统计关系是相关关系——有一定关系但是不完全确定
    • 用回归的方法研究变量之间的相关关系,回归分析和相关分析不一样
      • x与y的地位在回归中不同(分因变量和自变量——解释变量和被解释变量),在相关关系中不考虑差异(用相关系数衡量)
      • 随机变量与非随机变量:在相关分析里面两个变量都必须是随机变量,在回归中认为x是非随机的(应该是随机的,但是为了简化问题说是随机的)
      • 研究的目的与作用:回归主要的目的是解释结构和做预测,相关分析就是看相关性

    回归方程与回归名称的由来

    两个变量是有相关性的,一般来讲期望中二者的相关性比较高
    回归是由Galton和Pearson研究父母身高及其子女身高遗传问题的时候,发现有归回的现象,系数是0.5哇

    回归分析的主要内容及其一般模型

    • 主要内容:通过建立统计模型研究
      • 通过x去预测y是回归最核心的东西
      • 什么是y的最佳预测?
        我们企图用g(x)g(x)去预测y,取g(x)=E[YX]g(x)=E[Y|X]时,E(Yg(x))2E(Y-g(x))^2最小
        f(x)=E[YX]=β0+β1xf(x)=E[Y|X]=\beta_0+\beta_1x回归函数取线性的形式,所以叫线性回归
      • 什么是y的最佳线性预测?

    E(Yg(x))2=E(YE[YX]+E[YX]g(x))2E(Y-g(x))^2=E(Y-E[Y|X]+E[Y|X]-g(x))^2
    =E(YE[YX])2+E(E[YX]g(x))2=E(Y-E[Y|X])^2+E(E[Y|X]-g(x))^2
    +2E(YE[YX])(E[YX]g(x))+2E(Y-E[Y|X])(E[Y|X]-g(x))
    根据条件期望公式E(E[YX])=E(Y)E(E[Y|X])=E(Y),发现 E(YE[YX])(E[YX]g(x))=0E(Y-E[Y|X])(E[Y|X]-g(x))=0

    • 一般形式:y=f(x1,x2,...,xp)+ϵy = f(x_1,x_2,...,x_p)+\epsilon
      • y——被解释变量(因变量)
      • xix_i——解释变量(自变量)
      • ϵ\epsilon——随机误差项
    • 线性回归模型:y=β0+β1x1+...+βpxp+ϵy=\beta_0+\beta_1 x_1+...+\beta_p x_p + \epsilon
      • 线性模型指的是βi\beta_i是线性的,不要求xix_i是线性的,比如y=β0+β1x12+...+βpxpp+ϵy=\beta_0+\beta_1 x_1^2+...+\beta_p x_p^p + \epsilon也是线性的(可替换)
      • 基本假设
        • 解释变量x1,x2,...x_1,x_2,...是非随机变量,观测值xi1,...xipx_{i1},...x_{ip}是常数(希望从平均意义上看,E(Y|X)=E(Y),因为x是常数)
        • Gauss-Markov假定:等方差及不相关假定(最小二乘法——最佳线性无偏估计——的条件)
          • Eϵ=0E\epsilon=0
          • cov(ϵi,ϵj)=0cov(\epsilon_i,\epsilon_j)=0
          • Var(ϵi)=σ2Var(\epsilon_i)=\sigma^2——这个σ2\sigma^2同时反映了Y的方差(因为X是非随机的)
        • 正态分布的假定:ϵiN(0,σ2)\epsilon_i N(0,\sigma^2)
        • n>pn>p:样本量比待估参数要多

    把x看作随机变量
    E[ϵX]=E(Yf(x)X)=E[YX]f(x)=f(x)f(x)=0E[\epsilon|X]=E(Y-f(x)|X)=E[Y|X]-f(x)=f(x)-f(x)=0

    • 对于线性回归模型通常要研究的问题
      • 根据样本求出β0,β1,...,βp,σ2\beta_0,\beta_1,...,\beta_p,\sigma^2的估计
      • 对回归方程以及回归系数的种种假设进行检验
      • 根据回归方程进行预测和控制,以及进行实际问题的结构分析

    建立实际问题回归模型的过程(见书)


    第二章 一元线性回归

    一元线性回归模型

    • y=β0+β1x+ϵy = \beta_0+\beta_1 x+\epsilon 不是一个完整模型,完整模型要带假定条件,比如上面写的G-M条件,代入样本之后有yi=β0+β1xi+ϵiy_i = \beta_0+\beta_1 x_i+\epsilon_i——最好用矩阵的形式表示
    • 回归系数作何解释?
      • β0\beta_0表示E[YXi=0]E[Y|X_i=0]
      • β1\beta_1表示E[YX1=x+1]E[YX1=x]E[Y|X_1=x+1]-E[Y|X_1=x],随着x的增加,E[Y]E[Y]的单位增量(一元的回归模型)
      • βi\beta_i表示E[YXi=x+1]E[YXi=x]E[Y|X_i=x+1]-E[Y|X_i=x],随着xix_i的增加,E[Y]E[Y]的单位增量(其他因素不变——因为往往因素之间有相关关系)——类似偏导

    注意x是不是随机的,决定要不要加条件

    • 得到经验回归方程 y^=β0^+β1^x\hat y = \hat{\beta_0}+\hat{\beta_1}x
    • yxy|_x服从N(β0+β1x,σ2)N(\beta_0+\beta_1x,\sigma^2)

    参数β0,β1\beta_0,\beta_1的估计

    最小二乘估计的性质

    回归方程的显著性检验

    残差分析

    回归系数的区间估计

    预测和控制

    展开全文
  • 比数学3中回归增加的内容选修-统计案例引入线性回归模型ybxae了解模型中随机误差项e产生的原因了解相关指数 R2 和模型拟合的效果之间的关系了解残差图的作用利用线性回归模型解决一类非线性回归问题正确理解分析...
  • 回归分析是数据分析中最基础也是最重要的分析工具,绝大多数的数据分析问题,都可以使用回归的思想来解决回归分析的任务: 通过研究自变量X和因变量Y的相关关系,尝试去解释Y的形成机制,进而达到通过X去预测Y的...

    回归分析:

    回归分析是数据分析中最基础也是最重要的分析工具,绝大多数的数据分析问题,都可以使用回归的思想来解决。

    • 回归分析的任务:
      通过研究自变量X和因变量Y的相关关系,尝试去解释Y的形成机制,进而达到通过X去预测Y的目的。
    • 常见的回归分析有五类:
      线性回归、0‐1回归、定序回归、计数回归、生存回归
      其划分的依据是因变量Y的类型
      在这里插入图片描述
    • Y:俗称因变量,即因为别人的改变,而改变的变量。在实际应用中,Y常常是我们需要研究的那个核心变量。
    • 例:
      • 经济学家研究经济增长的决定因素,那么Y可以选取GDP增长率 (连续数值型变量)
      • P2P公司要研究借款人是否能按时还款,那么Y可以设计成一个二值变
        量,Y=0时代表可以还款,Y=1时代表不能还款 (0‐1型变量)
      • 消费者调查得到的数据(1表示非常不喜欢,2表示有点不喜欢,3表示一般般,4表示有点喜欢,5表示非常喜欢)(定序变量)
      • 管理学中RFM模型:F代表一定时间内,客户到访的次数,次数其实就是一个非负的整数 (计数变量)
      • 研究产品寿命、企业寿命甚至是人的寿命(这种数据往往不能精确的观测,例如现在要研究吸烟对于寿命的影响,如果选取的样本中老王60岁,现在还活的非常好,我们不可能等到他去世了再做研究,那怎么办呢?直接记他的寿命为60+,那这种数据就是截断的数据)(生存变量)
    • 回归分析要完成的三个使命:
      第一、识别重要变量;
      第二、判断相关性的方向;
      第三、要估计权重(回归系数)。

    不同数据类型的处理方法

    在这里插入图片描述

    • 建模比赛中,前两种数据类型最常考到;面板数据较为复杂,是经管类学生在中级计量经济学中才会学到的模型。

    • 横截面数据往往可以使用回归来进行建模,我们通过回归可以得到自变量与因变量之间的相关关系以及自变量的重要程度。

    • 时间序列数据往往需要进行我们进行预测,时间序列模型的选择也很多,需要根据题的情况选择合适的模型对数据进行建模。

    一元线性回归

    在这里插入图片描述
    具体讲解可参考:
    https://blog.csdn.net/weixin_47066458/article/details/113826330

    对于线性的理解:

    线性假定并不要求初始模型都呈y=β0 + β1*xi + μi 的严格线性关系,自变量与因变量可以通过变量替换而转化成线性模型,如:
    在这里插入图片描述
    在使用线性回归模型前,需要对数据进行预处理。(用Excel、Matlab、Stata等软件)

    内生性的研究:

    在这里插入图片描述
    如果满足误差项μ和所有自变量x均不相关,则称该回归模型具有外生性
    如果相关,则存在内生性,内生性会导致回归系数估计的不准确——不满足无偏性和一致性。
    即μ包含了所有与y相关,但未添加到回归模型中的变量,如果这些变量和我们已经添加的自变量相关,则存在内生性。

    内生性的蒙特卡洛模拟:
    %% 蒙特卡洛模拟:内生性会造成回归系数的巨大误差
    times = 300;  % 蒙特卡洛的次数
    R = zeros(times,1);  % 用来储存扰动项u和x1的相关系数
    K = zeros(times,1);  % 用来储存遗漏了x2之后,只用y对x1回归得到的回归系数
    for i = 1: times
        n = 30;  % 样本数据量为n
        x1 = -10+rand(n,1)*20;   % x1在-10和10上均匀分布,大小为30*1
        u1 = normrnd(0,5,n,1) - rand(n,1);  % 随机生成一组随机数
        x2 = 0.3*x1 + u1;   % x2与x1的相关性不确定, 因为我们设定了x2要加上u1这个随机数
        % 这里的系数0.3我随便给的,没特殊的意义,你也可以改成其他的测试。
        u = normrnd(0,1,n,1);  % 扰动项u服从标准正态分布
        y = 0.5 + 2 * x1 + 5 * x2 + u ;  % 构造y
        k = (n*sum(x1.*y)-sum(x1)*sum(y))/(n*sum(x1.*x1)-sum(x1)*sum(x1)); % y = k*x1+b 回归估计出来的k
        K(i) = k;
        u = 5 * x2 + u;  % 因为我们回归中忽略了5*x2,所以扰动项要加上5*x2
        r = corrcoef(x1,u);  % 2*2的相关系数矩阵
        R(i) = r(2,1);
    end
    plot(R,K,'*')
    xlabel("x_1和u'的相关系数")
    ylabel("k的估计值")
    

    核心解释变量和控制变量:

    • 无内生性(no endogeneity)要求所有解释变量均与扰动项不相关。这个假定通常太强,因为解释变量一般很多(比如,5‐15个解释变量),且需要保证它们全部外生。

    • 是否可能弱化此条件?答案是肯定的。解释变量可以区分为核心解释变量控制变量两类。

      • 核心解释变量:我们最感兴趣的变量,因此我们特别希望得到对其系数的一致估计(当样本容量无限增大时,收敛于待估计参数的真值 )。
      • 控制变量:我们可能对于这些变量本身并无太大兴趣;而之所以把它们也放入回归方程,主要是为了 “控制住” 那些对被解释变量有影响的遗漏因素。
    • 在实际应用中,我们只要保证核心解释变量与𝝁不相关即可。

    回归系数的两种解释:

    • 第一种解释:
      如:y=5.3 + 0.19x1 - 1.74x2,其中x1表示品质评分,x2表示该产品的价格,y为产品的销量。
      0.19:在保持其他变量不变的情况下,评分每增加一个单位,该产品的平均销量增加0.19;
      -1.74:在保持其他变量不变的情况下,价格每增加一个单位,该产品的平均销量减少1.74;
    • 第二种解释:
      在这里插入图片描述
    四类模型回归系数的解释:

    1、一元线性回归:𝑦 = 𝑎 + 𝑏𝑥 + 𝜇,x每增加1个单位,y平均变化b个单位;
    2、双对数模型:𝑙𝑛𝑦 = 𝑎 + 𝑏𝑙𝑛𝑥 + 𝜇,x每增加1%,y平均变化b%;
    3、半对数模型:𝑦 = 𝑎 + 𝑏𝑙𝑛𝑥 + 𝜇,x每增加1%,y平均变化b/100个单位;
    4、半对数模型:𝑙𝑛𝑦 = 𝑎 + 𝑏𝑥 + 𝜇,x每增加1个单位,y平均变化(100b)%。

    需要取对数后构成线性的情况:
    • 目前,对于什么时候取对数没有固定的规则,但是有些经验法则:

      • 与市场价值相关的,例如,价格、销售额、工资等都可以取对数;
      • 以年度量的变量,如受教育年限、工作经历等通常不取对数;
      • 比例变量,如失业率、参与率等,两者均可;
      • 变量取值必须是非负数,如果包含0,则可以对y取对数ln(1+y);
    • 取对数的好处:

      • 减弱数据的异方差性
      • 如果变量本身不符合正态分布,取了对数后可能渐近服从正态分布
      • 模型形式的需要,让模型具有经济学意义

    特殊的自变量——虚拟变量X

    如果自变量中有定性变量,例如性别、地域等,在
    回归中要怎么处理呢?
    例如:我们要研究性别对于工资的影响(性别歧视)
    在这里插入图片描述Female的解释:
    在这里插入图片描述
    为了避免完全多重共线性的影响,引入虚拟变量的个数一般是分类数减1,例如上例中我们只引入了Female而没有同时引入Female和Male。

    含有交互项的自变量

    例如:
    在这里插入图片描述

    利用Stata回归

    当跑出来的拟合优度R方较低

    1. 回归分为解释型回归和预测型回归。 预测型回归一般才会更看重𝑅方;
      解释型回归更多的关注模型整体显著性以及自变量的统计显著性和经济意义显著性即可。

    2. 可以对模型进行调整,例如对数据取对数或者平方后再进行回归。

    3. 数据中可能有存在异常值或者数据的分布极度不均匀。

    关于拟合优度和调整后的拟合优度:

    我们引入的自变量越多,拟合优度会变大。但我们倾向于使用调整后的拟合优度,如果新引入的自变量对SSE的减少程度特别少,那么调整后的拟合优度反而会减小。

    标准化回归系数

    为了更为精准的研究影响评价量的重要因素(去除量纲的影响),可考虑使用标准化回归系数。对数据进行标准化,就是将原始数据减去它的均数后,再除以该变量的标准差,计算得到新的变量值,新变量构成的回归方程称为标准化回归方程,回归后相应可得到标准化回归系数。
    标准化系数的绝对值越大,说明对因变量的影响就越大(只关注显
    著的回归系数)

    扰动项要满足的条件

    在之前的回归分析中,我们都默认了扰动项是球型扰动项。

    • 球型扰动项:满足“同方差”和“无自相关”两个条件。
      横截面数据容易出现异方差的问题;
      时间序列数据容易出现自相关的问题。

    解决异方差问题:

    1.如果扰动项存在异方差:

    (1)OLS估计出来的回归系数是无偏、一致的。
    (2)假设检验无法使用(构造的统计量失效了)。
    (3)OLS估计量不再是最优线性无偏估计量(BLUE)。

    2.怎么解决异方差:

    (1)使用OLS + 稳健的标准误
    如果发现存在异方差,一 种处理方法是,仍然进行OLS 回归,但使用稳健标
    准误。这是最简单,也是目前通用的方法。只要样本容量较大,即使在异方差的情况下,若使用稳健标准误,则所 有参数估计、假设检验均可照常进行。换言之,只要使用了稳健标准误,就可以与异方差“和平共处”了。
    (2)广义最小二乘估计法GLS
    原理:方差较大的数据包含的信息较少,我们可以给予信息量大的数据(即方差较小的数据更大的权重)
    缺点:我们不知道扰动项真实的协方差矩阵,因此我们只能用样本数据来估计,这样得到的结果不稳健,存在偶然性。

    注: 我们常用第一种方法来解决异方差

    3.异方差的假设检验:

    (1).BP检验
    (2).怀特检验

    我们无需掌握两种检验的原理,只需知道二者的异同:
    BP检验与怀特检验的区别在于,后者还包括平方项与交叉项。因此,BP检验可以看成是怀特检验的特例。BP检验的优点在于其建设性,即可以帮助确认异方差的具体形式。

    原假设:扰动项不存在异方差
    通过P值来检验扰动项是否存在异方差

    多重共线性

    在Stata中利用reg可以消除多重共线性,但是无法消除非常接近于多重共线性的项,这就有可能导致我们得到的结果不准确

    检验多重共线性:

    在这里插入图片描述

    多重共线性的处理方法:

    如果发现存在多重共线性,可以采取以下处理方法。

    • 如果不关心具体的回归系数,而只关心整个方程预测被解释变量的能力,则通常可以 不必理会多重共线性(假设你的整个方程是显著的)。这是因为,多重共线性的主要后果是使得对单个变量的贡献估计不准,但所有变量的整体效应仍可以较准确地估计;
    • 如果关心具体的回归系数,但多重共线性并不影响所关心变量的显著性,那么也可以不必理会。即使在有方差膨胀的情况下,这些系数依然显著;如果没有多重共线性,则只会更加显著。
    • 如果多重共线性影响到所关心变量的显著性,则需要增大样本容量,剔除导致严重共线性的变量(不要轻易删除哦,因为可能会有内生性的影响),或对模型设定进行修改。

    逐步回归分析

    • 向前逐步回归Forward selection:将自变量逐个引入模型,每引入一个自变量后都要进行检验,显著时才加入回归模型。
      (缺点:随着以后其他自变量的引入,原来显著的自变量也可能又变为不显著了,但是,并没有将其及时从回归方程中剔除掉。)

    • 向后逐步回归Backward elimination:与向前逐步回归相反,先将所有变量均放入模型,之后尝试将其中一个自变量从模型中剔除,看整个模型解释因变量的变异是否有显著变化,之后将最没有解释力的那个自变量剔除;此过程不断迭代,直到没有自变量符合剔除的条件。
      (缺点:一开始把全部变量都引入回归方程,这样计算量比较大。若对一些不重要的变量,一开始就不引入,这样就可以减少一些计算。当然这个缺点随着现在计算机的能力的提升,已经变得不算问题了)

      注意:
      (1)向前逐步回归和向后逐步回归的结果可能不同。
      (2)在我们的科研论文中不要轻易使用逐步回归分析,因为剔除了自变量后很有可能会产生新的问题,例如内生性问题。但是建模比赛中可以使用逐步回归分析。

    展开全文
  • 回归算法 ...线性回归是利用数理统计中回归分析,来确定两种或两种以上变量间相互依赖的定量关系的一种统计分析方法。 房价预测问题 很多用户具有购房的需求,但是往往咨询中介公司往往效率很低,
  • 主成分回归分析.sas

    2020-08-18 17:57:30
    利用SAS先对原始数据做主成分分析降维,然后根据降维后的特征向量构建多重线性回归模型,该方法通常用来解决多重线性回归模型在构建时,自变量的多重共线性问题
  • 线性回归是利用数理统计中回归分析,来确定两种或两种以上变量间相互依赖的定量关系的一种统计分析方法,运用十分广泛。其表达形式为y= w’x+e,e为误差服从均值为0的正态分布。 线性回归一般用于预测,比如价格涨跌...
  • 针对各学科领域中常遇到的一元或者多元线性回归问题,在简单介绍回归分析基本理论的基础上,结合具体实例,详细介绍了基于回归算法编写MATLAB程序、利用MATLAB预定义函数以及二者相结合解决多元线性回归问题的方法。...
  • 利用TensorFlow回归神经网络进行情感分析 中文字幕Sentiment Analysis with Recurrent Neural Networks in TensorFlow 情感分析和自然语言处理是使用机器学习技术解决的常见问题 在不通过评论的情况...
  • 文中通过采用某一个点的测井曲线或地震数据推测出该点的孔隙度或渗透率,基于多种测井信息的多元线性回归方法已成为储层孔隙度定量预测的主要方法,多元逐步回归分析方法的理论正好适用于这种实际问题。它是利用通过...
  • 二项logistic回归分析的适用条件里头,有一条规定自变量与logit(p)间应是线性关系,...以下为娜娜melisa博主的原文:最近在看冯老师出书《医学研究中的logistic回归分析及SAS实现》,对其中的说法“可先利用散点图大...
  • 回归分析主要解决问题有: (1)从一组样本数据出发,确定变量之间的数学关系式 (2)对这些关系式的可信程度进行各种统计检验,并从影响某一特定变量的诸多变量中找出那些变量的影响是显著的,那些事不显著的。 ...
  • 二分类的fisher模型采用spss进行多分类线性判别分析和逻辑回归操作1.引入:多种水果分类2. 多分类fisher判别 适用于二分类问题的逻辑回归和fisher线性判别法 1.引入:水果分类 已知两种水果的属性和名称,如果已知...
  •  现在仅仅是利用sklearn库中的现有方法实现训练和测试,但是由于手中现有的数据比较复杂,并不适合用线性回归的方法去拟合,所以效果并不理想。 1.首先是原始数据格式的问题:  我拿到的数据是csv格式的,用...
  • 除了理论分析外,我们还通过许多处理符号回归问题(包括函数拟合和混沌时间序列预测)的实验,将UGEP与现有GEP变体进行了比较。 实验结果表明,在解决符号回归问题上,UGEP在实现全局最优的能力和收敛速度方面均...
  • 线性回归与逻辑回归

    2019-09-18 19:12:47
    线性回归和逻辑回归是机器学习中基础又...通常来讲,线性回归,是利用数理统计中回归分析,来确定两种或两种以上变量间相互依赖的定量关系的一种统计分析方法。 表达形式为: y(x,w)=w0+w1x1+…+wnxn 如上图底部为...
  • 这个问题是典型的数据挖掘的问题,通过对数据的分析得出规律,然后利用规律对一些未知的数据的结果进行预测,又由于它只有房子面积大小这一个数据特征,所以又叫做一个变量的线性回归问题问题解决模型如下图: ...
  • 本节书摘来自华章计算机《大数据架构和算法实现之路:电商系统的...利用分类和聚类技术解决了前面两个问题之后,本章最终要关注小丽提出的第三大需求:在合理的范围内预测商品的销售转化率。“这项任务看上去不可能...
  • 嵌牛导读:randomForest 包提供了利用随机森林算法解决分类和回归问题的功能;我们这里只关注随机森林算法在分类问题中的应用嵌牛鼻子:R语言;随机森林嵌牛提问:如何使用R语言进行随机森林分析分析结果是怎样的...
  • 车辆跟驰模型是微观交通仿真的一个基本模型,基于非参数回归算法的跟车模型较好地解决了以往模型存在的典型问题,但随着样本维数增加,容易出现“维数祸根”现象。提出一种基于投影寻踪回归(PPR)技术的车辆跟驰...
  • 回归算法

    千次阅读 2019-04-29 09:39:24
    回归首先假设一些已知类型的函数可以拟合目标数据,然后利用某种误差分析确定一个与目标数据拟合程度最好的函数。回归模式的函数定义与分类模型相似,主要差别在于分类模型采取离散预测值(例如类标号),而回归模式...
  • 逻辑回归算法梳理

    2019-04-01 21:10:44
    线性回归通常是解决连续数值预测问题, 利用数理统计的回归分析, 来确定变量之间的相互依赖关系. 其公式通常表示如下: 逻辑回归定义 逻辑回归(Logistic Regression)通常用来解决二分类问题(也可以解决多分类...
  • 线性回归——正态分布来分析误差; 逻辑回归——伯努利分布来分析误差 线性回归用来做预测,LR用来做...线性回归通常是解决连续数值预测问题, 利用数理统计的回归分析, 来确定变量之间的相互依赖关系。线性回归中的...
  • 许多统计问题可以用简单方法解决,比如普通的最小二乘回归,其它问题可能需要复杂的机器学习方法。幸运的是,Python已经成为了运用这些分析方法的语言之一,因此读完此书,你可以探索许多工具。 本章中,我会回顾...
  • 机器学习_线性回归

    2018-03-12 20:08:49
    在统计学中,线性回归(LinearRegression)是利用称为线性回归方程的最小平方函数对一个或多个自变量和因变量之间关系进行建模的一种回归分析。这种函数是一个或多个称为回归系数的模型参数的线性组合。只有一个自变量...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 175
精华内容 70
关键字:

利用回归分析解决问题