Web安全之ML--构建机器学习工具箱

Web安全之ML–构建机器学习工具箱

python语言在机器学习领域的优势和应用，包括几个重点库：Numpy，SciPy，NTLK，Scikit-Learn的简介，环境依赖以及安装，并且介绍

一.python在机器学习领域的优势

python在机器学习领域应用广泛，主要原因有两个：

.语法简单，功能强大

.生态完整，具备丰富的第三方库

1.Numpy

Numpy是python的一种开源的数值计算扩展。这种工具可用来存储和处理大型矩阵，比python自身的嵌套列表结构要高效的多。Numpy是python数据科学计算的核心库，提供了高性能的多维数组及处理数组的工具

Numpy包括：

.一个强大的N维数组对象Array

.比较成熟的函数库

.用于整合c/c++和Fortran代码的工具包

.实用的线性代数，傅里叶变换和随机数生成函数

创建数组

>>> a = np.array([1,2,3])
>>> b = np.array([(1.5,2,3), (4,5,6)], dtype = float)
>>> c = np.array([[(1.5,2,3), (4,5,6)], [(3,2,1), (4,5,6)]], 
dtype = float)

初始化占位符

>>> np.zeros((3,4))                          创建值为0数组
>>> np.ones((2,3,4),dtype=np.int16)          创建值为1数组
>>> d = np.arange(10,25,5)                   创建均匀间隔的数组（步进值）
>>> np.linspace(0,2,9)                       创建均匀间隔的数组（样本数）
>>> e = np.full((2,2),7)                     创建常数数组
>>> f = np.eye(2)                            创建2x2单位矩阵
>>> np.random.random((2,2))                  创建随机值的数组
>>> np.empty((3,2))                          创建空数组

保存与载人磁盘上的文件

>>> np.save('my_array', a)
>>> np.savez('array.npz', a, b)
>>> np.load('my_array.npy')

保存与载人文本文件

>>> np.loadtxt("myfile.txt")
>>> np.genfromtxt("my_file.csv", delimiter=',')
>>> np.savetxt("myarray.txt", a, delimiter=" ")

数据类型

>>> np.int64                              带符号的64位整数
>>> np.float32                            标准双精度浮点数
>>> np.complex128                         显示为128位浮点数的复数
>>> np.bool                               布尔值：True值和False值
>>> np.object                             Python对象
>>> np.string_                            固定长度字符串
>>> np.unicode_                           固定长度Unicode

数组信息

>>> a.shape                               数组形状，几行几列
>>> len(a)                                数组长度
>>> b.ndim                                几维数组
>>> e.size                                数组有多少元素
>>> b.dtype                               数据类型
>>> b.dtype.name                          数据类型的名字
>>> b.astype(int)                         数据类型转换

调用帮助

>>> np.info(np.ndarray.dtype)

算数运算

>>> g = a - b
 array([[-0.5, 0. , 0. ],
[-3. , -3. , -3. ]])
>>> np.subtract(a,b)
>>> b + a 
 array([[ 2.5, 4. , 6. ],
[ 5. , 7. , 9. ]])
>>> np.add(b,a)
>>> a / b
 array([[ 0.66666667, 1. , 1. ],
[ 0.25 , 0.4 , 0.5 ]])
>>> np.divide(a,b)
>>> a * b
 array([[ 1.5, 4. , 9. ],
[ 4. , 10. , 18. ]])
>>> np.multiply(a,b)
>>> np.exp(b)
>>> np.sqrt(b)
>>> np.sin(a)
>>> np.cos(b)
>>> np.log(a)
>>> e.dot(f)
 array([[ 7., 7.],
[ 7., 7.]])

比较

>>> a == b                                     对比值
 array([[False, True, True],
[False, False, False]], dtype=bool)
>>> a < 2                                      对比值
 array([True, False, False], dtype=bool)
>>> np.array_equal(a, b)                       对比数组

聚合函数

>>> a.sum()                                    数组汇总
>>> a.min()                                    数组最小值
>>> b.max(axis=0)                              数组最大值，按行
>>> b.cumsum(axis=1)                           数组元素的累加值
>>> a.mean()                                   平均数
>>> b.median()                                 中位数
>>> a.corrcoef()                               相关系数
>>> np.std(b)                                  标准差

数组复制

>>> h = a.view()                               使用同一数据创建数组视图
>>> np.copy(a)                                 创建数组的副本
>>> h = a.copy()                               创建数组的深度拷贝

数组排序

>>> a.sort()                                   数组排序
>>> c.sort(axis=0)                             以轴为依据对数组排序

子集，切片，索引

子集
>>> a[2]                                       选择索引2对应的值
3
>>> b[1,2]                                     选择行1列2对应的值（等同于b[1][2])

选择矩阵的行列子集
 6.0
切片
>>> a[0:2]                                     选择索引为0与1对应的值
array([1, 2])
>>> b[0:2,1]                                   选择第1列中第0行、第1行的值
 array([ 2., 5.]) 
>>> b[:1]                                      选择第0行的所有值（等同于b[0:1,:1]
 array([[1.5, 2., 3.]]) 
>>> c[1,...]                                   等同于 [1,:,:]
 array([[[ 3., 2., 1.],
 [ 4., 5., 6.]]])
>>> a[ : :-1]                                  反转数组a
 array([3, 2, 1])
>>> a[a<2]                                     选择数组a中所有小于2的值
 array([1])
>>> b[[1, 0, 1, 0],[0, 1, 2, 0]]               选择(1,0),(0,1),(1,2)和(0,0)所对应的值
 array([ 4. , 2. , 6. , 1.5])
>>> b[[1, 0, 1, 0]][:,[0,1,2,0]]               选择矩阵的行列子集
array([[ 4. ,5. , 6. , 4. ],
 [ 1.5, 2. , 3. , 1.5],
 [ 4. , 5. , 6. , 4. ],
[ 1.5, 2. , 3. , 1.5]])

数组操作

转置数组
>>> i = np.transpose(b)                        转置数组
>>> i.T                                        转置数组
 改变数组形状
>>> b.ravel()                                  拉平数组
>>> g.reshape(3,-2)                            改变数组形状，但不改变数据
 添加或删除值
>>> h.resize((2,6))                            返回形状为(2,6)的新数组
>>> np.append(h,g)                             追加数据
>>> np.insert(a, 1, 5)                         插入数据
>>> np.delete(a,[1])                           删除数据

 合并数组
>>> np.concatenate((a,d),axis=0)               拼接数组
 array([ 1, 2, 3, 10, 15, 20])
>>> np.vstack((a,b))                           纵向以行的维度堆叠数组
 array([[ 1. , 2. , 3. ],
[ 1.5, 2. , 3. ],
 [ 4. , 5. , 6. ]])
>>> np.r_[e,f]                                 纵向以行的维度堆叠数组
>>> np.hstack((e,f))                           横向以列的维度堆叠数组
 array([[ 7., 7., 1., 0.], 
[ 7., 7., 0., 1.]])
>>> np.column_stack((a,d))                     以列的维度创建堆叠数组
 array([[ 1, 10],
[ 2, 15],
 [ 3, 20]])
>>> np.c_[a,d]                                 以列的维度创建堆叠数组

分割数组
>>> np.hsplit(a,3)                             纵向分割数组为3等份
 [array([1]),array([2]),array([3])]
>>> np.vsplit(c,2)                             横向分割数组为2等份
[array([[[ 1.5, 2. , 1. ],
[ 4. , 5. , 6. ]]]), 
 array([[[ 3., 2., 3.],
[ 4., 5., 6.]]])]

2.SciPy

SciPy是一款方便，易于使用，专为科学和工程设计的python工具包，它包括统计，优化，整合，线性代数模块，傅里叶变换，信号和图像处理，常微分方程求解器等等

与Numpy交互

>>> import numpy as np 
>>> a = np.array([1,2,3])
>>> b = np.array([(1+5j,2j,3j), (4j,5j,6j)])
>>> c = np.array([[(1.5,2,3), (4,5,6)], [(3,2,1), (4,5,6)]])

索引技巧

>>> np.mgrid[0:5,0:5]                            创建稠密栅格
>>> np.ogrid[0:2,0:2]                            创建开放栅格
>>> np.r_[[3,[0]*5,-1:1:10j]                     按行纵向堆叠数组按
>>> np.c_[b,c]                                   列横向堆叠数组

操控技巧

>>> np.transpose(b)                              转置矩阵
>>> b.flatten()                                  拉平数组
>>> np.hstack((b,c))                             按列横向堆叠数组
>>> np.vstack((a,b))                             按行纵向堆叠数组
>>> np.hsplit(c,2)                               在索引2横向分割数组
>>> np.vpslit(d,2)                               在索引2纵向分割数组

多项式

>>> from numpy import poly1d
>>> p = poly1d([3,4,5])                          创建多项式对象

矢量函数

>>> def myfunc(a): 
    if a < 0: 
        return a*2 
    else: 
        return a/2
>>> np.vectorize(myfunc)                          矢量函数

类型控制

>>> np.real(c)                                    返回数组元素的实部
>>> np.imag(c)                                    返回数组元素的虚部
>>> np.real_if_close(c,tol=1000)                  如果复数接近0，返回实部将
>>> np.cast['f'](np.pi)                           对象转化为数据类型

常用函数

>>> np.angle(b,deg=True)                          返回复数的角度
>>> g = np.linspace(0,np.pi,num=5)                创建等差数组（样本数）
>>> g [3:] += np.pi
>>> np.unwrap(g)                                  解包
>>> np.logspace(0,10,3)                           创建等差数组（对数刻度）
>>> np.select([c<4],[c*2])                        根据条件返回数组列表的值
>>> misc.factorial(a)                             因子
>>> misc.comb(10,3,exact=True)                    取K次N项的组合，已改为scipy.special.comb
>>> misc.central_diff_weights(3)                  NP点中心导数的权重
>>> misc.derivative(myfunc,1.0)                   查找函数在某点的第n个导数

线性代数：使用linalg和sparse模块。注意scipy.linalg包含numpy.linalg，并扩展了其功能

创建矩阵

>>> A = np.matrix(np.random.random((2,2)))
>>> B = np.asmatrix(b)
>>> C = np.mat(np.random.random((10,5)))
>>> D = np.mat([[3,4], [5,6]])

基础矩阵例程

逆矩阵
>>> A.I                                              求逆矩阵
>>> linalg.inv(A)                                    求逆矩阵
>>> A.T                                              矩阵转置
>>> A.H                                              共轭转置
>>> np.trace(A)                                      计算对角线元素的和
 范数
>>> linalg.norm(A)                                   Frobenius 范数
>>> linalg.norm(A,1)                                 L1 范数 (最大列汇总)
>>> linalg.norm(A,np.inf)                            L 范数 (最大列汇总)
 排名
>>> np.linalg.matrix_rank(C)                         矩阵排名
 行列式
>>> linalg.det(A)                                    行列式
 求解线性问题
>>> linalg.solve(A,b)                                求解稠密矩阵
>>> E = np.mat(a).T                                  求解稠密矩阵
>>> linalg.lstsq(D,E)                                用最小二乘法求解线性代数方程
 广义逆
>>> linalg.pinv(C)                                   计算矩阵的伪逆（最小二乘法求解器）
>>> linalg.pinv2(C)                                  计算矩阵的伪逆（SVD）

创建稀疏矩阵

>>> F = np.eye(3, k=1)                               创建2X2单位矩阵
>>> G = np.mat(np.identity(2))                       创建2X2单位矩阵
>>> C[C > 0.5] = 0                                   
>>> H = sparse.csr_matrix(C)                         压缩稀疏列矩阵
>>> I = sparse.csc_matrix(D)                         压缩稀疏列矩阵
>>> J = sparse.dok_matrix(A)                         DOK矩阵
>>> E.todense()                                      将稀疏矩阵转为全矩阵
>>> sparse.isspmatrix_csc(A)                         单位稀疏矩阵

稀疏矩阵例程

逆矩阵
>>> sparse.linalg.inv(I)
 范数
>>> sparse.linalg.norm(I) 
 解决线性问题
>>> sparse.linalg.spsolve(H,I) 稀求解疏

稀疏矩阵函数

>>> sparse.linalg.expm(I) 稀疏矩阵指数

调用帮助

>>> help(scipy.linalg.diagsvd)
>>> np.info(np.matrix)

矩阵函数

加法
>>> np.add(A,D)
 减法
>>> np.subtract(A,D)
 除法
>>> np.divide(A,D)
 乘法
>>> np.multiply(D,A)                                  乘法
>>> np.dot(A,D)                                       点积
>>> np.vdot(A,D)                                      向量点积
>>> np.inner(A,D)                                     内积
>>> np.outer(A,D)                                     外积
>>> np.tensordot(A,D)                                 张量点积
>>> np.kron(A,D)                                      Kronnecker积
 指数函数
>>> linalg.expm(A)                                    矩阵指数
>>> linalg.expm2(A)                                   矩阵指数（泰勒级数）
>>> linalg.expm3(D)                                   矩阵指数（特征值分解）
 对数函数
>>> linalg.logm(A)                                    矩阵对数
 三角函数
>>> linalg.sinm(D)                                    矩阵正弦
>>> linalg.cosm(D)                                    矩阵余弦
>>> linalg.tanm(A)                                    矩阵切线
 双曲三角函数
>>> linalg.sinhm(D)                                   双曲矩阵正弦
>>> linalg.coshm(D)                                   双曲矩阵余弦
>>> linalg.tanhm(A)                                   双曲矩阵切线
 矩阵符号函数 
>>> np.sigm(A)                                        矩阵符号函数
 矩阵平方根
>>> linalg.sqrtm(A)                                   矩阵平方根
 任意函数 
>>> linalg.funm(A, lambda x: x*x)                     评估矩阵函数

矩阵分解

特征值与特征向量 
>>> la, v = linalg.eig(A)                           求解方阵的普通或广义特征值问题
>>> l1, l2 = la                                     解包特征值
>>> v[:,0]                                          第一个特征值
>>> v[:,1]                                          第二个特征值
>>> linalg.eigvals(A)                               解包特征值
 奇异值分解
>>> U,s,Vh = linalg.svd(B)                          奇异值分解（SVD）
>>> M,N = B.shape
>>> Sig = linalg.diagsvd(s,M,N)                     在 SVD 中构建 Sigma 矩阵
 LU 分解
>>> P,L,U = linalg.lu(C)                            LU 分解

解构稀疏矩阵

>>> la, v = sparse.linalg.eigs(F,1)                  特征值与特征向量
>>> sparse.linalg.svds(H, 2)                         奇异值分解（SVD）

3.NLTK

NLTK在NLP领域中是最常使用的一个python库，包括图形演示和示例数据，其提供的教程解释了工具包支持的语言处理任务背后的基本概念

4.Scikit-Learn

Scikit-Learn是基于python的机器学习模块，基于BSD开源许可证。Scikit-Learn官方网站上可以找到相关的Scikit-Learn的资源，模块下载，文档，例程等等。Scikit-Learn的基本功能主要分为6个部分：分类，回归，聚类，数据降维，模型选择，数据预处理

依赖的环境：

.python(>=2.6 or >=3.3)

.Numpy(>=1.6.1)

.SciPy(>=0.9)

安装：pip install -U scikit-learn

Scikit-Learn通过统一的界面实现机器学习，预处理，交叉验证及可视化算法

>>> from sklearn import neighbors, datasets, preprocessing
>>> from sklearn.model_selection import train_test_split
>>> from sklearn.metrics import accuracy_score
>>> iris = datasets.load_iris()
>>> X, y = iris.data[:, :2], iris.target
>>> X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=33)
>>> scaler = preprocessing.StandardScaler().fit(X_train)
>>> X_train = scaler.transform(X_train)
>>> X_test = scaler.transform(X_test)
>>> knn = neighbors.KNeighborsClassifier(n_neighbors=5)
>>> knn.fit(X_train, y_train)
>>> y_pred = knn.predict(X_test)
>>> accuracy_score(y_test, y_pred)

加载数据

Scikit-learn 处理的数据是存储为 NumPy 数组或 SciPy 稀疏矩阵的数字，还支持 Pandas 数据框等可转换为数字数组的其它数据类型

>>> import numpy as np
>>> X = np.random.random((10,5))
>>> y = np.array(['M','M','F','F','M','F','M','M','F','F','F'])
>>> X[X < 0.7] = 0

训练集与测试集数据

>>> from sklearn.model_selection import train_test_split
>>> X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

创建模型

有监督学习评估器

线性回归
>>> from sklearn.linear_model import LinearRegression
>>> lr = LinearRegression(normalize=True)
>>> from sklearn.svm import SVC
>>> svc = SVC(kernel='linear') 
>>> from sklearn.naive_bayes import GaussianNB
>>> gnb = GaussianNB()
KNN
>>> from sklearn import neighbors
>>> knn = neighbors.KNeighborsClassifier(n_neighbors=5)

无监督学习评估器

主成分分析(PCA)
>>> from sklearn.decomposition import PCA
>>> pca = PCA(n_components=0.95)
 K Means
>>> from sklearn.cluster import KMeans
>>> k_means = KMeans(n_clusters=3, random_state=0)

模型拟合

有监督学习
>>> lr.fit(X, y)                               拟合数据与模型
>>> knn.fit(X_train, y_train)__
>>> svc.fit(X_train, y_train) 
 无监督学习
>>> k_means.fit(X_train)__                     拟合数据与模型
>>> pca_model = pca.fit_transform(X_train)     拟合并转换数据

预测

有监督评估器
>>> y_pred = svc.predict(np.random.random((2,5)))              预测标签
>>> y_pred = lr.predict(X_test)                                预测标签
>>> y_pred = knn.predict_proba(X_test)                         评估标签概率
 无监督评估器
>>> y_pred = k_means.predict(X_test)                           预测聚类算法里的标签

数据预处理

标准化

>>> from sklearn.preprocessing import StandardScaler
>>> scaler = StandardScaler().fit(X_train)
>>> standardized_X = scaler.transform(X_train)
>>> standardized_X_test = scaler.transform(X_test)

归一化

>>> from sklearn.preprocessing import Normalizer
>>> scaler = Normalizer().fit(X_train)
>>> normalized_X = scaler.transform(X_train)
>>> normalized_X_test = scaler.transform(X_test)

二值化

>>> from sklearn.preprocessing import Binarizer
>>> binarizer = Binarizer(threshold=0.0).fit(X)
>>> binary_X = binarizer.transform(X)

编码分类特征

>>> from sklearn.preprocessing import LabelEncoder
>>> enc = LabelEncoder()
>>> y = enc.fit_transform(y)

输入缺失值

>>> from sklearn.preprocessing import Imputer
>>> imp = Imputer(missing_values=0, strategy='mean', axis=0)
>>> imp.fit_transform(X_train)

生成多项式特征

>>> from sklearn.preprocessing import PolynomialFeatures
>>> poly = PolynomialFeatures(5)
>>> poly.fit_transform(X)

评估模型性能

分类指标

正确率
>>> knn.score(X_test, y_test)                                  评估器评分发法
>>> from sklearn.metrics import accuracy_score                 指标评分函数
>>> accuracy_score(y_test, y_pred)
分类预估评价函数 
>>> from sklearn.metrics import classification_report          精确度，召回率，F1    
>>> print(classification_report(y_test, y_pred))               分数即支持率
混淆矩阵
>>> from sklearn.metrics import confusion_matrix
>>> print(confusion_matrix(y_test, y_pred))

回归指标

平均绝对误差
>>> from sklearn.metrics import 
mean_absolute_error >>> y_true = [3, -0.5, 2]
>>> mean_absolute_error(y_true, y_pred)
 均方误差
>>> from sklearn.metrics import mean_squared_error
>>> mean_squared_error(y_test, y_pred)
R² 评分
>>> from sklearn.metrics import r2_score
>>> r2_score(y_true, y_pred)

群集指标

调整兰德系数
>>> from sklearn.metrics import adjusted_rand_score
>>> adjusted_rand_score(y_true, y_pred) 
 同质性
>>> from sklearn.metrics import homogeneity_score
>>> homogeneity_score(y_true, y_pred) 
V-measure
>>> from sklearn.metrics import v_measure_score
>>> metrics.v_measure_score(y_true, y_pred)

交叉验证

>>> from sklearn.cross_validation import cross_val_score
>>> print(cross_val_score(knn, X_train, y_train, cv=4))
>>> print(cross_val_score(lr, X, y, cv=2))

模型调整

栅格搜索

>>> from sklearn.grid_search import GridSearchCV
>>> params = {"n_neighbors": np.arange(1,3), 
"metric": ["euclidean", "cityblock"]}
>>> grid = GridSearchCV(estimator=knn, 
 param_grid=params)
>>> grid.fit(X_train, y_train)
>>> print(grid.best_score_)
>>> print(grid.best_estimator_.n_neighbors)

随机参数优化

>>> from sklearn.grid_search import RandomizedSearchCV
>>> params = {"n_neighbors": range(1,5), 
"weights": ["uniform", "distance"]}
>>> rsearch = RandomizedSearchCV(estimator=knn, 
param_distributions=params, cv=4,
 n_iter=8, 
 random_state=5)
>>> rsearch.fit(X_train, y_train)
>>> print(rsearch.best_score_)

二.Tensorflow简介与环境搭建

Tensorflow是一个采用数据流图，用于数值计算的开源软件库。节点在图中表示数学操作，图中的线则表示在节点间相互联系的多维数据数组，即张量

Tensorflow的特点：

.高度的灵活性

.真正的可移植性

.将科研和产品联系在一起

.自动求微分

.多语言支持

.性能最优化

由于前面写过Tensorflow关于深度神经网络的文章，不懂请看前面文章