回归算法（python code）----------机器学习系列（一）

前面一篇把回归算法的理论部分都大致讲过了，这一篇主要就python代码部分做一些解释，也就是怎么用python写回归算法，因为LZ也是刚刚入门，有一些理解不对的地方，欢迎大家指正，LZ也矫枉过正。
首先是python模块----numpy (设计用到的数学函数，数组等），然后是画图模块matplotlib.pyplot,读取数据集的模块pandas，最后一个就是sklearn,最大的特点就是，为用户提供各种机器学习算法的接口，可以让用户简单、高效地进行数据挖掘和数据分析。这里呢，就引用两个函数，分别为：
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
首先介绍一个简单的线性回归的例子来热热身，感受一下：

data=pandas.read_csv(‘*.csv’）#读取csv文件里的数据，放到data

x=data[[‘TV’,’Radio’,’Newspaper’]] #读取data数据集里的三列作为x

y=data[‘Sales’] #读取data数据集里的一列作为y

x_train,x_test,y_train,y_test=train_test_split(x,y,random_state=1)#把data数据集分为训练集和测试集

linreg=LinearRegression() #调用线性回归函数

model=linreg.fit(x_train,y_train)#用训练集来拟合出线性回归模型

可以打印出model,回归系数和截距

print model

print linreg.coef_

print linreg.intercept_

下面是用测试数据来拟合或者说预测

y_hat=linreg.predict(numpy.array(x_test))

下面说一下画图

t=numpy.arange(len(x_test)) #t是一个等差数列，长度为x_test的数量

plt.plot(t,y_test,’r-‘,linewidth=2,label=’Test’) #plot(x,y,颜色和标识，标识的宽度，标识名)

plt.plot(t,y_hat,’g-‘,linewidth=2,label=’Predict’)#plot(x,y,颜色和标识，标识的宽度，标识名)

plt.legend(loc=’upper right’) #legend是图示说明

plt.grid()#网格显示

plt.show()#图像显示

==============================================

经过上面的例子，想必大家会有点感觉了，下面呢，我们再深入的去钻研一下，Lasso回归和Ridge回归

首先是导入模块部分，前面是线性回归，这里类似

from sklearn.model_selection import train_test_split

from sklearn.linear_model import Lasso,Ridge

from sklearn.model_selection import GridSearchCV #GridSearchCV模块，能够在指定的范围内自动搜索具有不同超参数的不同模型组合

pandas读取数据集与上面的类似

data=pandas.read_csv(‘*.csv’)

x=data[[‘TV’,’Radio’,’Newspaper’]]

y=data[‘sales’]

把数据集分为训练集和测试集

x_train,x_test,y_train,y_test=train_test_split(x,y,random_state=1)

model=Lasso() #或者model=Ridge() #选定模型

alpha_can=np.logspace(-3,2,10) #alpha参数集 10^-3~10^2的等比数列的10个数

lasso_model=GridSearchCV(model,param_grid={‘alpha’:alpha_can},cv=5)#其中cv可以是整数或者交叉验证生成器或一个可迭代器，cv参数对应4种输入：

1、None:默认参数，哈数会使用默认的3折交叉验证

2、整数k：K折交叉验证。对于分类任务，使用stratifiedFold(类别平衡，每类的训练集占比一样多），对于其他任务，使用Kfold

3、交叉验证生成器：得自己写生成器，头疼，略

4、可以生成训练集与测试集的迭代器：同上，略

lasso_model.fit(x,y) #用所用的X，Y来拟合

print lasso_model.best_params_ #验证参数

y_hat=lasso_model.predict(np.array(x_test))#用测试数据来拟合或者预测

画图：

t=np.arange(len(x_test))

plt.plot(t,y_test,’r-‘,linewidth=2,label=’Test’)

plt.plot(t,y_hat,’g-‘,linewidth=2,label=’Predict’)

plt.legend(loc=’upper right’)

plt.grid()

plt.show()

==========================================

上面的代码只是多了对于超参数的处理，多个超参数，找出最好的一个，下面我们再仔细研究一下logisticRegression 逻辑回归的代码

模块的导入

from sklearn.linear_model import LogisticRegression

这里再增加几个预处理的模块：

from sklearn import preprocessing

from sklearn.preprocessing import StandardScaler #上一篇章已经讲过，这里再赘述一下，是做标准化，（通过删除均值和缩减成单位方差来标准化特征，一般是用x=standardScaler().fit_transform(x)）

from sklearn.pipeline import Pipeline#组装几个可以交叉验证的步骤，同时设置不同的参数，管道是前一个输出是下一个步骤的输入，管道中间步骤必须是转换，也就是说必须要实现拟合和转换方法）

# 路径，浮点型数据，逗号分隔，第4列使用函数iris_type单独处理

data = np.loadtxt(path, dtype=float, delimiter=’,’, converters={4: iris_type})

# 将数据的0到3列组成x，第4列得到y

x, y = np.split(data, (4,), axis=1)

x = StandardScaler().fit_transform(x)

lr = LogisticRegression() # Logistic回归模型

lr.fit(x, y.ravel()) # 根据数据[x,y]，计算回归参数

# 等价形式

lr = Pipeline([(‘sc’, StandardScaler()),

(‘clf’, LogisticRegression()) ])

lr.fit(x, y.ravel())

# 画图

N, M = 500, 500 # 横纵各采样多少个值

x1_min, x1_max = x[:, 0].min(), x[:, 0].max() # 第0列的范围

x2_min, x2_max = x[:, 1].min(), x[:, 1].max() # 第1列的范围

t1 = np.linspace(x1_min, x1_max, N)

t2 = np.linspace(x2_min, x2_max, M)

x1, x2 = np.meshgrid(t1, t2) # 生成网格采样点

x_test = np.stack((x1.flat, x2.flat), axis=1) # 测试点

y_hat = lr.predict(x_test) # 预测值

y_hat = y_hat.reshape(x1.shape) # 使之与输入的形状相同

plt.pcolormesh(x1, x2, y_hat, cmap=cm_light) # 预测值的显示

plt.scatter(x[:, 0], x[:, 1], c=y, edgecolors=’k’, s=50, cmap=cm_dark) #样本的显示

plt.xlabel(‘petal length’)

plt.ylabel(‘petal width’)

plt.xlim(x1_min, x1_max)

plt.ylim(x2_min, x2_max)

plt.grid()

plt.savefig(‘2.png’)

plt.show()

# 训练集上的预测结果

y_hat = lr.predict(x)

y = y.reshape(-1)

acc = np.mean(result)

print ‘准确度: %.2f%%’ % (100 * acc)

==========================================

线性回归的常见的算法大致都说了一下，不过在回归中有种过拟合的非常常见，接下来我们再讲一下过拟合：

当某个模型过度的学习训练数据中的细节和噪音，以至于模型在新的数据上表现很差，我们称过拟合发生了。这意味着训练数据中的噪音或者随机波动也被当做概念被模型学习了。而问题就在于这些概念不适用于新的数据，从而导致模型泛化性能的变差。

简单理解就是训练样本的得到的输出和期望输出基本一致，但是测试样本输出和测试样本的期望输出相差却很大 。为了得到一致假设而使假设变得过度复杂。

欠拟合指的是模型在训练和预测时表现都不好的情况。一个欠拟合的机器学习模型不是一个良好的模型并且由于在训练数据上表现不好这是显然的。

限制过拟合的方法

**使用重采样来评价模型效能

保留一个验证数据集**

最流行的重采样技术是 k 折交叉验证。指的是在训练数据的子集上训练和测试模型k次，同时建立对于机器学习模型在未知数据上表现的评估。

验证集只是训练数据的子集，你把它保留到你进行机器学习算法的最后才使用。在训练数据上选择和调谐机器学习算法之后，我们在验证集上在对于模型进行评估，以便得到一些关于模型在未知数据上的表现的认知。

对于机器学习，使用交叉验证在未知数据上进行验证模型效能是一种良好的标准。如果拥有数据，使用验证集也是一种良好的实践。

一句话概括：

过拟合：在训练数据上表现良好，在位置数据上表现差。

欠拟合：在训练数据和未知数据上表现都很差。

导入模块部分：

大致与前面的差不多，只是多了一个

from sklearn.preprocessing import PolynomialFeatures

在理解下面代码之前，先介绍一下PolynomialFeatures函数，我的理解是：专门产生多项式的，并且多项式包含的是相互影响的特征集。比如：一个输入样本是２维的。形式如[a,b] ,则二阶多项式的特征集如下[1,a,b,a^2,ab,b^2]。

参数理解：（一共只有３个参数）

degree : integer

多项式的阶数，一般默认是２。

interaction_only : boolean, default = False

如果值为true(默认是false),则会产生相互影响的特征集。

include_bias : boolean

是否包含偏差列

1.fit(X, y=None)

计算输出特征的个数

2.fit_transform(X, y=None, **fit_params)

输入参数：输入特征矩阵

返回：输出特征矩阵

例子如下：

X = np.arange(6).reshape(3, 2)

X

array([[0, 1],

[2, 3],

[4, 5]])

poly = PolynomialFeatures(2)　＃设置多项式阶数为２，其他的默认

poly.fit_transform(X)

array([[ 1, 0, 1, 0, 0, 1],

[ 1, 2, 3, 4, 6, 9],

[ 1, 4, 5, 16, 20, 25]])

poly = PolynomialFeatures(interaction_only=True)＃默认的阶数是２，同时设置交互关系为true

poly.fit_transform(X)

array([[ 1, 0, 1, 0],

[ 1, 2, 3, 6],

[ 1, 4, 5, 20]])

model_1 = Pipeline([
('poly', PolynomialFeatures()),
('linear', LinearRegression(fit_intercept=False))])
model_2 = Pipeline([
('poly', PolynomialFeatures()),
('linear', RidgeCV(alphas=np.logspace(-3, 2, 100),    fit_intercept=False))])

==================================

用于可在python文件里输入中文的代码：

mpl.rcParams[‘font.sans-serif’] = [u’simHei’]

mpl.rcParams[‘axes.unicode_minus’] = False

==========================

d_pool = np.arange(1, N, 1) # 阶

for t in range(2):

model = models[t]

plt.subplot(2, 1, t+1)

plt.plot(x, y, ‘ro’, ms=10, zorder=N)

for i, d in enumerate(d_pool):

model.set_params(poly__degree=d)

model.fit(x, y)

lin = model.get_params(‘linear’)[‘linear’]

if t == 0:

print u’%d阶，系数为：’ % d, lin.coef_.ravel()

else:

print u’%d阶，alpha=%.6f，系数为：’ % (d, lin.alpha_), lin.coef_.ravel()

x_hat = np.linspace(x.min(), x.max(), num=100)

x_hat.shape = -1, 1

y_hat = model.predict(x_hat)

s = model.score(x, y)

print s, ‘\n’

zorder = N - 1 if (d == 2) else 0

plt.plot(x_hat, y_hat, color=clrs[i], lw=line_width[i], label=(u’%d阶，score=%.3f’ % (d, s)), zorder=zorder)

剩下的就是画图了。