回归分析总结

Nov 18, 2016

回归分析是一种很重要的预测建模技术。主要是研究自变量与因变量之间的因果关系。本文将会从数学角度与代码角度分析不同类型的回归。当你想预测连续型的非独立变量,或者对一系列独立变量或输入项有所反应时,就会使用到回归分析。如果非独立变量是二分的,那么我们将会使用到逻辑回归。

对于回归技术的分类,在这里我不想过多细分,但是一般回归会依赖于三个方面进行区分: +自变量数目 +回归函数曲线的形状 +因变量的类型

首先我们来了解下面几种常用的回归算法模型

简单线性回归(Simple Linear Regression)

简单线性回归是最基础的一种回归模型,自变量只有一个,函数曲线为直线,因变量为连续型,自变量可以是连续的或者是离散的。函数表示如下:

其中 y 是因变量, x是自变量, β0 和 β1 属于起始值和系数,ε 为偏移量,为了使得到的函数模型更加准确,最后会加上偏移量。

figure 1

线性回归一般使用最小二乘法来求解函数模型级求解 β0 和 β1 。 方法如下:最小二乘法

figure 2

如图中四个点为数据(x,y):(1,6)(2,5)(3,7)(4,10)。我们需要根据红色的数据来求蓝色的曲线。目前我们已知这四个点匹配直线y= β1 + β2x 。所以我们要找到符合这条直线的最佳情况,即最合适的β0 和 β1。

figure 3

最小二乘法就是尽量取两边方差的最小值,这样可以找到最拟合的曲线。

figure 4

然后我们我们同时对β0和β1求其偏导数

figure 5

这样我们很容易就解除方程组的解

figure 6

所以我们就得到了直线 y=3.5 + 1.4x

用Python和Java代码表示如下:

# -*- coding: utf-8 -*-
"""
Created on Thu Dec 01 00:02:49 2016

@author: steve
"""

def SLR(x,y):
    intercept = 0.0
    slope = 0.0
    n = len(x)

    sumx = 0.0
    sumy = 0.0
    sumx2 = 0.0

# 第一次循环,得到平均值
    for i in range(n):
        sumx += x[i]
        sumy += y[i]
        sumx2 += x[i]*x[i]

    xbar = sumx/n
    ybar = sumy/n

    xxbar = 0.0
    yybar = 0.0
    xybar = 0.0

# 第二次循环,得到方差
    for i in range(n):
        xxbar += (x[i] - xbar) * (x[i] - xbar);
        yybar += (y[i] - ybar) * (y[i] - ybar);
        xybar += (x[i] - xbar) * (y[i] - ybar);

# 计算斜率和intercept
    slope  = xybar / xxbar
    intercept = ybar - slope * xbar

    print "slope is {}, intercept is {}".format(slope, intercept)
## 其他统计变量我就不写了。

x=[1,2,3,4]
y=[6,5,7,10]
SLR(x,y)


package regression;

public class SLR {

	// 这是用二分法做的简单线性回归

	private final double intercept, slope;
	private final double r2;
	private final double svar0, svar1;

	public SLR(double[] x, double[] y) {

		if (x.length != y.length) {
			throw new IllegalArgumentException("lengths doesn't match!!!");
		}

		int n = x.length;

		// 第一次循环,找到 所有x和y的平均值

		double sumx = 0.0;
		double sumy = 0.0;
		double sumx2 = 0.0;

		for (int i=0; i<n; i++) {
			sumx += x[i];
			sumy += y[i];
			sumx2 += x[i]*x[i];
		}

		double xbar = sumx / n;
		double ybar = sumy / n;

		// 第二次计算,求出方差
        double xxbar = 0.0;
        double yybar = 0.0;
        double xybar = 0.0;
        for (int i = 0; i < n; i++) {
            xxbar += (x[i] - xbar) * (x[i] - xbar);
            yybar += (y[i] - ybar) * (y[i] - ybar);
            xybar += (x[i] - xbar) * (y[i] - ybar);
        }
        System.out.println(xxbar);
        System.out.println(yybar);
        System.out.println(xybar);
        slope  = xybar / xxbar;  //求偏导数的过程
        intercept = ybar - slope * xbar;

        // 其他的统计数据
        double rss = 0.0;      // residual sum of squares
        double ssr = 0.0;      // regression sum of squares
        for (int i = 0; i < n; i++) {
            double fit = slope*x[i] + intercept;
            rss += (fit - y[i]) * (fit - y[i]);
            ssr += (fit - ybar) * (fit - ybar);
        }

        int degreesOfFreedom = n-2;
        r2    = ssr / yybar;
        double svar  = rss / degreesOfFreedom;
        svar1 = svar / xxbar;
        svar0 = svar/n + xbar*xbar*svar1;		

	}

	public double intercept() {
		return intercept;

	}

	public double slope() {
		return slope;

	}

	public double R2() {
		return r2;
	}

	public double slopeStdErr() {
		return Math.sqrt(svar1);
	}

	public double interceptStdErr() {
		return Math.sqrt(svar0);
	}

	//这是预测方法,在机器学习中的函数
	public double predict(double x) {
		return slope*x + intercept;
	}

	public String toString() {
		StringBuilder s = new StringBuilder();
		s.append(String.format("%.2f n + %.2f", slope(), intercept()));
		s.append("  (R^2 = " + String.format("%.3f", R2()) + ")");
		return s.toString();
	}

}


多元线性回归类似于简单线性回归,只不过自变量不止一个,但是过程和方法与简单线性回归一样。这里我只把代码放出来。




多项式回归(Polynomial Regression)

如果一个方程,自变量的指数大于1,那么所有拟合这个方程的点就符合多项式回归。

figure 7

多项式回归有个很重要的因素就是指数(degree)。如果我们发现数据的分布大致是一条曲线,那么很可能符合多项式回归,但是我们不知道degree是多少。所以我们只能一个个去试,直到找到最拟合分布的degree。这个过程我们可以交给数据科学软件完成。需要注意的是,如果degree选择过大的话可能会导致函数过于拟合, 意味着对数据或者函数未来的发展很难预测,也许指向不同的方向。

这个回归的计算需要用到矩阵数据结构。有的编程语言可能需要导入外库。

figure 8

我们对所有拟合这个公式的点,用矩阵表示他们的关系

figure 9

如果用矩阵符号表示:

figure 10

多项式回归向量的系数(使用最小二乘法):

figure 11

Java 和 Python 代码如下:



package regression;
import Jama.Matrix;
import Jama.QRDecomposition;

public class PR {

	private final int N;
	private final int degree;
	private final Matrix beta;
	private double SSE;
	private double SST;

	public PR(double[] x, double[] y, int degree) {
		this.degree = degree;
        N = x.length;

        // build Vandermonde matrix
        double[][] vandermonde = new double[N][degree+1];
        for (int i = 0; i < N; i++) {
            for (int j = 0; j <= degree; j++) {
                vandermonde[i][j] = Math.pow(x[i], j);
            }
        }
        Matrix X = new Matrix(vandermonde);

        // 从向量中增加一个矩阵
        Matrix Y = new Matrix(y, N);

        // 找到最小的平方值
        QRDecomposition qr = new QRDecomposition(X);
        beta = qr.solve(Y);


        // 得到y的平均值
        double sum = 0.0;
        for (int i = 0; i < N; i++)
            sum += y[i];
        double mean = sum / N;

        // total variation to be accounted for
        for (int i = 0; i < N; i++) {
            double dev = y[i] - mean;
            SST += dev*dev;
        }

        // variation not accounted for
        Matrix residuals = X.times(beta).minus(Y);
        SSE = residuals.norm2() * residuals.norm2();
	}

	public double beta(int j) {
		return beta.get(j, 0);
	}

	public int degreee() {
		return degree;
	}

	public double R2() {
		return 1.0 - SSE/SST;
	}

	public double predict(double x) {

		double y = 0.0;
		for (int j = degree; j>=0; j--) {
			y = beta(j) + (x*y);
		}
		return y;
	}

	public String toString() {
        String s = "";
        int j = degree;

        // 忽略系数为0.
        while (Math.abs(beta(j)) < 1E-5)
            j--;

        // create remaining terms
        for (j = j; j >= 0; j--) {
            if      (j == 0) s += String.format("%.2f ", beta(j));
            else if (j == 1) s += String.format("%.2f N + ", beta(j));
            else             s += String.format("%.2f N^%d + ", beta(j), j);
        }
        return s + "  (R^2 = " + String.format("%.3f", R2()) + ")";
    }

}

逻辑回归(Logistic Regression)

逻辑回归是我最喜欢的一种回归,因为表达的是概率事件。

Probit model

逐步回归(Stepwise Regression)

岭回归(Ridge Regression)

套索回归(Lasso Regression)

弹性网(Elastic net)

本文参考了Sunil Ray的7 Types of Regression Techniques you should know!

机器学习(二):线性回归

Nov 17, 2016

回归分析是一种预测性的建模技术,它研究的是因变量(目标)和自变量(预测器)之间的关系。这种技术通常用于预测分析,时间序列模型以及发现变量之间的因果关系。例如,司机的鲁莽驾驶与道路交通事故数量之间的关系,最好的研究方法就是回归。 回归分析是建模和分析数据的重要工具。在这里,我们使用曲线/线来拟合这些数据点,在这种方式下,从曲线或线到数据点的距离差异最小。

有关线性回归的研究及代码实现请参考我的另一篇文章。

线性回归是最贴近生活的数据模型之一。

简单的线性回归

简单的线性回归公式如下:

figure 2.1

从公式中我们可以看出,简单线性回归只有一个自变量x1,b1是自变量的系数,y是因变量。x1可能是连续型或者离散型的数据,所以我们需要通过x1找出最合适的系数b1从而得到关于因变量y的曲线。

我们下面用一个例子来说明,这是一个关于工作经验与薪水之间关系的表格。分布如下图所示

figure 2.2

从charter上我们很容易看出这是符合一个线性回归的模型,下面我们就要做出回归的函数并且对未来数据进行预测。

我们用上一节写过的模板来处理数据:

# Importing the libraries
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

# Importing the dataset
dataset = pd.read_csv('Salary_Data.csv')
X = dataset.iloc[:, :-1].values#除了最后一列的其他列
y = dataset.iloc[:, 1].values #第二列

# Splitting the dataset into the Training set and Test set
from sklearn.cross_validation import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 0)

一般Python的library会自动进行feature scaling,所以我们不需要自己动手。

我们将数据按照4:1分为训练组和测试组两部分。每一组分别包含自变量和因变量

figure 2.3

下面我们需要做的是通过训练集的X_train与y_train 计算出符合训练集的曲线,然后将测试集的X_test 带入得到的曲线中,得到预测的结果y_pred,最后将预测结果y_pred与测试集中的y_test进行比较,看看是否符合分布,从而确定预测是否准确。

# Fitting Simple LinearRegression to the training set
from sklearn.linear_model import LinearRegression
regressor = LinearRegression()
regressor.fit(X_train,y_train) # 通过train集找到曲线

y_pred = regressor.predict(X_test)

# visualising the Traning set results
plt.scatter(X_train, y_train, color = 'red')
plt.plot(X_train, regressor.predict(X_train), color = 'blue')
plt.title('Salary vs Experience(Traning set)')
plt.xlabel('Year of Experience')
plt.ylabel('Salary')
plt.show()

通过学习我们可以得到训练曲线

figure 2.4

下面我们导入测试数据

plt.scatter(X_test, y_test, color = 'red')
plt.plot(X_train, regressor.predict(X_train), color = 'blue')
plt.title('Salary vs Experience(Traning set)')
plt.xlabel('Year of Experience')
plt.ylabel('Salary')
plt.show()

figure 2.5

这里需要注意两点,第一,在导入测试集时我们依然使用训练集得到的曲线,所以我们的plot函数中参数不便,当然如果你用测试集的数据应该也会得到相同的曲线。 第二有的人觉得既然需要预测数据应该将y_test 替换成 y_pred。 其实不需要这样的。因为我们y_pred 上的点应该都是和曲线高度重合的,如图:

figure 2.6

这样一个简单线性回归的机器学习功能就完成啦~~最后我贴出R语言实现的步骤。

# Simple Linear Regression

# Importing the dataset
dataset = read.csv('Salary_Data.csv')

# Splitting the dataset into the Training set and Test set
# install.packages('caTools')
library(caTools)
set.seed(123)
split = sample.split(dataset$Salary, SplitRatio = 2/3)
training_set = subset(dataset, split == TRUE)
test_set = subset(dataset, split == FALSE)

# Feature Scaling
# training_set = scale(training_set)
# test_set = scale(test_set)

# Fitting Simple Linear Regression to the Training set
regressor = lm(formula = Salary ~ YearsExperience,
               data = training_set)

# Predicting the Test set results
y_pred = predict(regressor, newdata = test_set)

# Visualising the Training set results
library(ggplot2)
ggplot() +
  geom_point(aes(x = training_set$YearsExperience, y = training_set$Salary),
             colour = 'red') +
  geom_line(aes(x = training_set$YearsExperience, y = predict(regressor, newdata = training_set)),
            colour = 'blue') +
  ggtitle('Salary vs Experience (Training set)') +
  xlab('Years of experience') +
  ylab('Salary')

# Visualising the Test set results
library(ggplot2)
ggplot() +
  geom_point(aes(x = test_set$YearsExperience, y = test_set$Salary),
             colour = 'red') +
  geom_line(aes(x = training_set$YearsExperience, y = predict(regressor, newdata = training_set)),
            colour = 'blue') +
  ggtitle('Salary vs Experience (Test set)') +
  xlab('Years of experience') +
  ylab('Salary')

多重线性回归(Multiple Linear Regression)

多重线性回归将会不只有一个自变量,并且每个自变量拥有自己的系数且符合线性回归。

figure 2.7

在建立多重线性回归之前,有这么几个前提必须要注意一下,这些有助于你判断数据是否适合使用多重线性回归: 1, 线性(linearity) 2, 同方差(Homoscedasticity) 3, 多元正态性(Multivariate normality) 多因素共同影响分布结果 4, 错误的独立性(independence of errors) 每一个变量产生的错误将会独立的影响预测结果,不会对其他变量产生影响 5, 多重共线性的缺乏(lack of multicollinearity) 变量之间存在高度相关关系而使得回归估算不准确,如接下来要提到的虚拟变量陷阱(dummy variable trap)有可能触发多重共线性的问题

虚拟变量陷阱(Dummy variable trap)

在前一章中已经提到过,在回归预测中我们需要所有的数据都是numeric的,但是会有一些非numeric的数据,比如国家,省,部门,性别。这时候我们需要设置虚拟变量(Dummy variable)。做法是将此变量中的每一个值,衍生成为新的变量,是设为1,否设为0.举个例子,“性别”这个变量,我们可以虚拟出“男”和”女”两虚拟变量,男性的话“男”值为1,”女”值为,;女性的话“男”值为0,”女”值为1。

但是要注意,这时候虚拟变量陷阱就出现了。就拿性别来说,其实一个虚拟变量就够了,比如 1 的时候是“男”, 0 的时候是”非男”,即为女。如果设置两个虚拟变量“男”和“女”,语义上来说没有问题,可以理解,但是在回归预测中会多出一个变量,多出的这个变量将会对回归预测结果产生影响。一般来说,如果虚拟变量要比实际变量的种类少一个。

所以在多重线性回归中,变量不是越多越好,而是选择适合的变量。这样才会对结果准确预测。

建立模型

我们可以通过以下五个步骤建立回归模型:(stepwise Regression)

1, 确立所有的可能(变量all in) 建立所有的个模型包含所有可能的变量

2, 逆向消除(backward elimination) (1)选择一个差异等级(significance level)比如SL=0.05, 0.05 意味着此变量对结果有95%的贡献。 P(A|B) = 0.05 (2)将所有的变量放进你的模型中。 (3)选择P值最高的变量,如果P>SL。到第四步,否则结束,完成建模。关于变量的P值,统计软件可以计算出并选择最高P值的变量 (4)移除此变量,并重新进行第三步。 有关逆向消除和逐步回归的方法,可以参考一下两个链接: Backward elimination and stepwise regression Variable Selection

3, 正向选择(forward selection) (1)选择一个差异等级(significance level)比如SL=0.05 (2)建立所有的简单回归的模型,并找到最小的P值 (3)确立一个简单模型,并将拥有最小P值的变量加入此模型 (4)如果P>SL,模型建立成功,否则在进行第三步

4,双向消除(bidirectionnal elimination) 同时进行逆向消除和正向选择。

所有可能的模型:意思是所有变量排列组合成的模型,如果有N个变量,那么一共会有2的N次方个模型(2^N-1) *在R语言中,每一个变量后面会用星号表示此变量对回归模型的影响,星号越多越重要。

Stepwise Regression 这是宾夕法尼亚州立大学的讲解。我觉得挺不错的 另外,其实这几步不是很难,关键的一点是SL值的确定。还有就是P值的生成。

如何计算P值(p-value)

figure 2.8

假定有两组人群,一组x=0,另一组x=1。从两组中各随机抽取2个个体,测量Y 的值,如图所示,看看这两组的Y是否相同? 现在各组再多抽取若干个体,数据如图所示,可以计算各组的均数,这两个均 数不在同一条线上,这是从所抽取的样本中估计出来的。从样本中得到的两个 均数不等于两组总体的均数,从样本中得到的两均数距离不等于两个总体均数 的差,t 检验是根据两样本均数及两样本的标准差,计算如果两总体均数相同的 话,抽样得到两样本均数差达如此之大或更大的可能性多大,就是p 值,p值 <0.05,表示两者之间的距离显著。 现在看回归分析,建立回归方程如上所示。从方程中看,当x=0时,Y=β0;当x=1 时,Y=β0 + β1。因此,β0表示X=0组Y的均数,β1表示X=1组Y的均数与X=0组Y的均 数的差,ei是每个个体与其所在组均数的差。因此回归方程对β1= 0 的检验等同 于t检验两组均数的比较。

用Python和R进行操作

我们可以使用之前建立的模板,将数据导入。

今天我们使用一个多变量对商业profit影响的数据集。

figure 2.9

在此数据集中,我们确定前四个变量(R&D Speed, Administration, Marketing Speed, State)为自变量。最后一个profit为因变量。

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

# Importing the dataset
dataset = pd.read_csv('50_Startups.csv')
X = dataset.iloc[:, :-1].values
y = dataset.iloc[:, 4].values

由于数据中包含state变量,我们用虚拟变量代替

from sklearn.preprocessing import LabelEncoder, OneHotEncoder
labelencoder = LabelEncoder()
X[:, 3] = labelencoder.fit_transform(X[:, 3])
onehotencoder = OneHotEncoder(categorical_features = [3])
X = onehotencoder.fit_transform(X).toarray()
#为了避免虚拟变量陷阱
X = X[:, 1:] #从1 开始,并非0

figure 2.10

将数据集分为训练集和测试集,我们选择test size为0.2(4:1)

from sklearn.cross_validation import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 0)

执行多重线性回归:

from sklearn.linear_model import LinearRegression
regressor = LinearRegression()
regressor.fit(X_train, y_train)

得到预测结果:

y_pred = regressor.predict(X_test)

我们比较一下预测结果(y_pred)和实际结果(y_test)中的差异

figure 2.11

plt.scatter(np.arange(10),y_test, color = 'red',label='y_test')
plt.scatter(np.arange(10),y_pred, color = 'blue',label='y_pred')
plt.legend(loc=2);
plt.show()

figure 2.12

其实很多结果还是很接近的。

这样我们就完成了多元线性回归的建模过程。其实我们与简单线性回归比较一下,代码完全相同,所以在sklearn的线性回归库中没有简单或者多元的区分。但是多元线性回归很难用图像表示,因为包含多个自变量。

下面是R的代码,方法是一样的,但是有些地方需要说明一下的: 首先建模代码不难我就不多解释了,其中我们需要用到 caTools的库,需要提前导入一下,

# 导入数据
dataset = read.csv('50_Startups.csv')

# 虚拟变量
dataset$State = factor(dataset$State,
                       levels = c('New York', 'California', 'Florida'),
                       labels = c(1, 2, 3))

# install.packages('caTools')
library(caTools)
set.seed(123)
split = sample.split(dataset$Profit, SplitRatio = 0.8)
training_set = subset(dataset, split == TRUE) # 多自变量
test_set = subset(dataset, split == FALSE) # 单因变量

# 多重线性回归
regressor = lm(formula = Profit ~ .,
               data = training_set)

# 预测结果
y_pred = predict(regressor, newdata = test_set)

我们执行一下summary(regressor) 来看看这个factor的结构:

figure 2.13

首先,R语言自动对虚拟变量进行了优化,所以我们不需要担心虚拟变量陷阱的问题。

从图中我们可以看出,RD Speed对结果影响很大,注意P值,只有RD Speed 是小于0.05的,其他的都挺大的。所以RD Speed对结果贡献很大。之后我们就可以移除其他的保留这个。

Signif. codes 表示此变量对结果的significance level,也就是重要性有多大。

至此多元线性回归就结束了。

多项式回归(polinomial regression)

首先我们需要明确一个概念,我们讨论的线性或者非线性针对的是自变量的系数,而非自变量本身,所以这样的话不管自变量如何变化,自变量的系数如果符合线性我们就说这是线性的。所以这里我们也就可以描述一下多项式线性回归。

figure 2.14

由此公式我们可以看出,自变量只有一个,就是x,只不过x的级数(degree)不同而已。

我们这次用的数据是公司内部不同的promotion level所对应的薪资

figure 2.15

下面我们来看一下在Python中是如何实现的

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

dataset = pd.read_csv('Position_Salaries.csv')
X = dataset.iloc[:, 1:2].values
# 这里注意:1:2其实只有第一列,与1 的区别是这表示的是一个matrix矩阵,而非单一向量。
y = dataset.iloc[:, 2].values

figure 2.16

接下来,进入正题,开始多项式线性回归:

from sklearn.preprocessing import PolynomialFeatures
poly_reg = PolynomialFeatures(degree = 1) #degree 就是自变量需要的维度
X_poly = poly_reg.fit_transform(X)
lin_reg_2 = LinearRegression()
lin_reg_2.fit(X_poly, y)

这个过程我们设置了一元一次的自变量:degree=1 意思是自变量只有一次,相当于简单线性回归 我们在图像中表示一下:

# 图像中显示
plt.scatter(X, y, color = 'red')
plt.plot(X, lin_reg_2.predict(poly_reg.fit_transform(X)), color = 'blue')
plt.title('Truth or Bluff (Polynomial Regression)')
plt.xlabel('Position level')
plt.ylabel('Salary')
plt.show()

figure 2.17

此图像与用简单线性回归表示的图像是一样的

# 简单线性回归 图像中显示
plt.scatter(X, y, color = 'red')
plt.plot(X, lin_reg.predict(X), color = 'blue')
plt.title('Truth or Bluff (Linear Regression)')
plt.xlabel('Position level')
plt.ylabel('Salary')
plt.show()

figure 2.18

下面我们试着改变一下维度,将degree设置成2,其他不改变,执行一下代码看看图像:

figure 2.19

我们可以发现整个趋势符合数据的分布。

我们将degree改成3 和 4 看看结果

figure 2.20

figure 2.21

我们可以发现,当degree=4的时候,基本上已经符合所有点的分布了

我们通过拆分横坐标将图像变得平滑一些:

X_grid = np.arange(min(X), max(X), 0.1)
X_grid = X_grid.reshape((len(X_grid), 1))
plt.scatter(X, y, color = 'red')
plt.plot(X_grid, lin_reg_2.predict(poly_reg.fit_transform(X_grid)), color = 'blue')
plt.title('Truth or Bluff (Polynomial Regression)')
plt.xlabel('Position level')
plt.ylabel('Salary')
plt.show()

figure 2.22

下面我们给出一个测试值来试试结果 (6,10)

lin_reg_2.predict(poly_reg.fit_transform(6))   
lin_reg_2.predict(poly_reg.fit_transform(10))

figure 2.23

与实际值还是比较接近的。

一下是R的代码

dataset = read.csv('Position_Salaries.csv')
dataset = dataset[2:3]

lin_reg = lm(formula = Salary ~ .,
             data = dataset)

# Fitting Polynomial Regression to the dataset
dataset$Level2 = dataset$Level^2
dataset$Level3 = dataset$Level^3
dataset$Level4 = dataset$Level^4
poly_reg = lm(formula = Salary ~ .,
              data = dataset)

              library(ggplot2)
              ggplot() +
                geom_point(aes(x = dataset$Level, y = dataset$Salary),
                           colour = 'red') +
                geom_line(aes(x = dataset$Level, y = predict(lin_reg, newdata = dataset)),
                          colour = 'blue') +
                ggtitle('Truth or Bluff (Linear Regression)') +
                xlab('Level') +
                ylab('Salary')

# install.packages('ggplot2')
library(ggplot2)
ggplot() +
  geom_point(aes(x = dataset$Level, y = dataset$Salary),
             colour = 'red') +
  geom_line(aes(x = dataset$Level, y = predict(poly_reg, newdata = dataset)),
            colour = 'blue') +
  ggtitle('Truth or Bluff (Polynomial Regression)') +
  xlab('Level') +
  ylab('Salary')

# install.packages('ggplot2')
library(ggplot2)
x_grid = seq(min(dataset$Level), max(dataset$Level), 0.1)
ggplot() +
  geom_point(aes(x = dataset$Level, y = dataset$Salary),
             colour = 'red') +
  geom_line(aes(x = x_grid, y = predict(poly_reg,
                                        newdata = data.frame(Level = x_grid,
                                                             Level2 = x_grid^2,
                                                             Level3 = x_grid^3,
                                                             Level4 = x_grid^4))),
            colour = 'blue') +
  ggtitle('Truth or Bluff (Polynomial Regression)') +
  xlab('Level') +
  ylab('Salary')

# 预测新的数据
predict(lin_reg, data.frame(Level = 6.5))
summaryss(poly_reg)

figure 2.24

我们可以看到模型的系数之间的关系

支持向量回归(support vector regression)

支持向量回归是属于支持向量机(support vector machine)的一种

cite works:

陈常中:线性回归分析(http://www.empowerstats.com/manuals/presentations/regression.pdf)