ml PCA降维算法

PCA降维算法

PCA（Principal Component Analysis）是一种常用的数据分析方法。PCA通过线性变换将原始数据变换为一组各维度线性无关的表示，可用于提取数据的主要特征分量，常用于高维数据的降维。

在这里，对于具体的算法概论不做过多的介绍，在 https://blog.csdn.net/daaikuaichuan/article/details/53444639 里有详细的介绍。

在机器学习中，主要解决的是将多组特征向量变少，比如100组变成10组。如果数据是保密的，也可以进行PCA算法进行加密，将高维信息转化之后，数据就没有之前的具体意义了。

 

PCA的算法步骤：

 

设有m条n维数据。

 

1）将原始数据按列组成n行m列矩阵X

 

2）将X的每一行（代表一个属性字段）进行零均值化，即减去这一行的均值

 

3）求出协方差矩阵

 

4）求出协方差矩阵的特征值及对应的特征向量

 

5）将特征向量按对应特征值大小从上到下按行排列成矩阵，取前k行组成矩阵P

 

6）即为降维到k维后的数据

 

PCA本质上是将方差最大的方向作为主要特征，并且在各个正交方向上将数据“离相关”，也就是让它们在不同正交方向上没有相关性。

因此，PCA也存在一些限制，例如它可以很好的解除线性相关，但是对于高阶相关性就没有办法了，对于存在高阶相关性的数据，可以考虑Kernel PCA，通过Kernel函数将非线性相关转为线性相关，关于这点就不展开讨论了。另外，PCA假设数据各主特征是分布在正交方向上，如果在非正交方向上存在几个方差较大的方向，PCA的效果就大打折扣了。

最后需要说明的是，PCA是一种无参数技术，也就是说面对同样的数据，如果不考虑清洗，谁来做结果都一样，没有主观参数的介入，所以PCA便于通用实现，但是本身无法个性化的优化。

 

 

 下面就是最喜闻乐见的python代码实现部分了。

"""
    pca:(主成分分析)降维算法

"""
from numpy import*
import pandas as pd
import matplotlib.pyplot as plt


class PcaM(object):

    def __init__(self):
        pass

    """
    读取数据格式化成矩阵
    """

    def loadData(self, filename, delim='\t'):
        data = pd.read_csv(filename)
        x = data[list(range(4))]
        print (x)
        return mat(x)

    def pca(self, dataMat, maxFeature=105):
        meanValue = mean(dataMat, axis=0)
        # 去中心，元数据减去均值，值得新的矩阵均值为0
        dataRemMat = dataMat - meanValue
        # 求矩阵的协方差矩阵
        covMat = cov(dataRemMat, rowvar=0)
        print ("-------covMatt------")
        print (covMat)
        # 求特征值和特徵向量
        feaValue, feaVect = linalg.eig(mat(covMat))
        print ("-------特征值-------")
        print (feaValue)
        print ("-------特征向量-------")
        print (feaVect)
        # 返回从小到大的索引值print "feaSort" + str(feaValueSort)
        feaValueSort = argsort(feaValue)
        feaValueTopN = feaValueSort[:-(maxFeature + 1):-1]
        redEigVects = feaVect[:, feaValueTopN]  # 选择之后的特征向量矩阵
        print ("--------TopN特征向量矩阵--------")
        print (redEigVects)
        print (shape(redEigVects))
        lowDataMat = dataRemMat * redEigVects  # 数据矩阵*特征向量矩阵 得到降维后的矩阵
        reconMat = lowDataMat * redEigVects.T + meanValue #这一步做数据恢复，并没有看懂这么做的意义
        print (lowDataMat)
        return lowDataMat, reconMat

    def plotW(self, lowDataMat, reconMat):
        fig = plt.figure()
        ax = fig.add_subplot(111)
        ax.scatter(lowDataMat[:, 0], lowDataMat[:, 1], marker='*', s=90)
        ax.scatter(reconMat[:, 0], reconMat[:, 1], marker='*', s=50, c='red')
        plt.show()

    def replaceNanWithMean(self):
        datMat = self.loadData('testdata.txt', ' ')
        numFeat = shape(datMat)[1]
        for i in range(numFeat):
            # values that are not NaN (a number)
            meanVal = mean(datMat[nonzero(~isnan(datMat[:, i].A))[0], i])
            # set NaN values to mean
            datMat[nonzero(isnan(datMat[:, i].A))[0], i] = meanVal
        print(datMat)
        return datMat


if __name__ == "__main__":
    p = PcaM()
    dataMat = p.replaceNanWithMean()
    lowDataMat, reconMat = p.pca(dataMat, 2)
    p.plotW(dataMat, reconMat)

 

参数
n_components：一个整数，指定降维后的维数
属性
explained_variance_ratio_：一个数组，元素是每个主成分explained variance的比例

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets,decomposition,manifold

def load_data():
    iris=datasets.load_iris()
    return iris.data,iris.target

def test_PCA(*data):
    X,y=data
    pca=decomposition.PCA(n_components=None)
    pca.fit(X)
    print('explained variance ratio : %s'%str(pca.explained_variance_ratio_))

X,y=load_data()
test_PCA(X,y)

def plot_PCA(*data):
    X,y=data
    pca=decomposition.PCA(n_components=2)
    pca.fit(X)
    X_r=pca.transform(X)

    fig=plt.figure()
    ax=fig.add_subplot(1,1,1)
    colors=((1,0,0),(0,1,0),(0,0,1),(0.5,0.5,0),(0,0.5,0.5),(0.5,0,0.5),(0.4,0.6,0),(0.6,0.4,0),(0,0.6,0.4),(0.5,0.3,0.2))
    for label,color in zip(np.unique(y),colors):
        position=y==label
        ax.scatter(X_r[position,0],X_r[position,1],label="target=%d"%label,color=color)
    ax.set_xlabel("X[0]")
    ax.set_ylabel("Y[0]")
    ax.legend(loc="best")
    ax.set_title("PCA")
    plt.show()
plot_PCA(X,y)

超大规模数据降维IncrementalPCA
可以将数据分批加载进内存。

3、KernelPCA
decomposition.KernelPCA( )
参数
n_components：一个整数，指定降维后的维数，如果为None，则维数不变。
kernel：一个字符串，指定核函数
–linear：线性核
–poly：多项式核
–rbf：高斯核函数
–sigmoid
alpha：一个整数，岭回归的超参数，用于计算逆转矩阵（当fit_inverse_transform=True时）。inverse：逆，transform：转。先逆后转。
属性
lambdas_：核化矩阵的特征值
alphas_：核化矩阵的特征向量
dual_coef_：逆转换矩阵
方法
fit（X[ , y]）:训练模型
transform(X)：执行降维
fit_transform（X[ , y]）:训练模型并且降维
inverse_transform(X):执行升维，将数据从低维空间逆向转换到原始空间

import numpy as np
import matplotlib.pyplot as plt
from sklearn import   datasets,decomposition

def load_data():
    '''
    加载用于降维的数据
    :return: 一个元组，依次为训练样本集和样本集的标记
    '''
    iris=datasets.load_iris()# 使用 scikit-learn 自带的 iris 数据集
    return  iris.data,iris.target

def test_KPCA(*data):
    '''
    测试 KernelPCA 的用法
    :param data: 可变参数。它是一个元组，这里要求其元素依次为：训练样本集、训练样本的标记
    :return: None
    '''
    X,y=data
    kernels=['linear','poly','rbf','sigmoid']
    for kernel in kernels:
        kpca=decomposition.KernelPCA(n_components=None,kernel=kernel) # 依次测试四种核函数
        kpca.fit(X)
        print('kernel=%s --> lambdas: %s'% (kernel,kpca.lambdas_))
def plot_KPCA(*data):
    '''
    绘制经过 KernelPCA 降维到二维之后的样本点
    :param data: 可变参数。它是一个元组，这里要求其元素依次为：训练样本集、训练样本的标记
    :return: None
    '''
    X,y=data
    kernels=['linear','poly','rbf','sigmoid']
    fig=plt.figure()
    colors=((1,0,0),(0,1,0),(0,0,1),(0.5,0.5,0),(0,0.5,0.5),(0.5,0,0.5),
        (0.4,0.6,0),(0.6,0.4,0),(0,0.6,0.4),(0.5,0.3,0.2),)# 颜色集合，不同标记的样本染不同的颜色

    for i,kernel in enumerate(kernels):
        kpca=decomposition.KernelPCA(n_components=2,kernel=kernel)
        kpca.fit(X)
        X_r=kpca.transform(X)# 原始数据集转换到二维
        ax=fig.add_subplot(2,2,i+1) ## 两行两列，每个单元显示一种核函数的 KernelPCA 的效果图
        for label ,color in zip( np.unique(y),colors):
            position=y==label
            ax.scatter(X_r[position,0],X_r[position,1],label="target= %d"%label,
            color=color)
        ax.set_xlabel("X[0]")
        ax.set_ylabel("X[1]")
        ax.legend(loc="best")
        ax.set_title("kernel=%s"%kernel)
    plt.suptitle("KPCA")
    plt.show()
def plot_KPCA_poly(*data):
    '''
    绘制经过 使用 poly 核的KernelPCA 降维到二维之后的样本点
    :param data: 可变参数。它是一个元组，这里要求其元素依次为：训练样本集、训练样本的标记
    :return: None
    '''
    X,y=data
    fig=plt.figure()
    colors=((1,0,0),(0,1,0),(0,0,1),(0.5,0.5,0),(0,0.5,0.5),(0.5,0,0.5),
        (0.4,0.6,0),(0.6,0.4,0),(0,0.6,0.4),(0.5,0.3,0.2),)# 颜色集合，不同标记的样本染不同的颜色
    Params=[(3,1,1),(3,10,1),(3,1,10),(3,10,10),(10,1,1),(10,10,1),(10,1,10),(10,10,10)] # poly 核的参数组成的列表。
            # 每个元素是个元组，代表一组参数（依次为：p 值， gamma 值， r 值）
            # p 取值为：3，10
            # gamma 取值为 ：1，10
            # r 取值为：1，10
            # 排列组合一共 8 种组合
    for i,(p,gamma,r) in enumerate(Params):
        kpca=decomposition.KernelPCA(n_components=2,kernel='poly'
        ,gamma=gamma,degree=p,coef0=r)  # poly 核，目标为2维
        kpca.fit(X)
        X_r=kpca.transform(X)# 原始数据集转换到二维
        ax=fig.add_subplot(2,4,i+1)## 两行四列，每个单元显示核函数为 poly 的 KernelPCA 一组参数的效果图
        for label ,color in zip( np.unique(y),colors):
            position=y==label
            ax.scatter(X_r[position,0],X_r[position,1],label="target= %d"%label,
            color=color)
        ax.set_xlabel("X[0]")
        ax.set_xticks([]) # 隐藏 x 轴刻度
        ax.set_yticks([]) # 隐藏 y 轴刻度
        ax.set_ylabel("X[1]")
        ax.legend(loc="best")
        ax.set_title(r"$ (%s (x \cdot z+1)+%s)^{%s}$"%(gamma,r,p))
    plt.suptitle("KPCA-Poly")
    plt.show()
def plot_KPCA_rbf(*data):
    '''
    绘制经过 使用 rbf 核的KernelPCA 降维到二维之后的样本点
    :param data: 可变参数。它是一个元组，这里要求其元素依次为：训练样本集、训练样本的标记
    :return: None
    '''
    X,y=data
    fig=plt.figure()
    colors=((1,0,0),(0,1,0),(0,0,1),(0.5,0.5,0),(0,0.5,0.5),(0.5,0,0.5),
        (0.4,0.6,0),(0.6,0.4,0),(0,0.6,0.4),(0.5,0.3,0.2),)# 颜色集合，不同标记的样本染不同的颜色
    Gammas=[0.5,1,4,10]# rbf 核的参数组成的列表。每个参数就是 gamma值
    for i,gamma in enumerate(Gammas):
        kpca=decomposition.KernelPCA(n_components=2,kernel='rbf',gamma=gamma)
        kpca.fit(X)
        X_r=kpca.transform(X)# 原始数据集转换到二维
        ax=fig.add_subplot(2,2,i+1)## 两行两列，每个单元显示核函数为 rbf 的 KernelPCA 一组参数的效果图
        for label ,color in zip( np.unique(y),colors):
            position=y==label
            ax.scatter(X_r[position,0],X_r[position,1],label="target= %d"%label,
            color=color)
        ax.set_xlabel("X[0]")
        ax.set_xticks([]) # 隐藏 x 轴刻度
        ax.set_yticks([]) # 隐藏 y 轴刻度
        ax.set_ylabel("X[1]")
        ax.legend(loc="best")
        ax.set_title(r"$\exp(-%s||x-z||^2)$"%gamma)
    plt.suptitle("KPCA-rbf")
    plt.show()
def plot_KPCA_sigmoid(*data):
    '''
    绘制经过 使用 sigmoid 核的KernelPCA 降维到二维之后的样本点
    :param data: 可变参数。它是一个元组，这里要求其元素依次为：训练样本集、训练样本的标记
    :return: None
    '''
    X,y=data
    fig=plt.figure()
    colors=((1,0,0),(0,1,0),(0,0,1),(0.5,0.5,0),(0,0.5,0.5),(0.5,0,0.5),
        (0.4,0.6,0),(0.6,0.4,0),(0,0.6,0.4),(0.5,0.3,0.2),)# 颜色集合，不同标记的样本染不同的颜色
    Params=[(0.01,0.1),(0.01,0.2),(0.1,0.1),(0.1,0.2),(0.2,0.1),(0.2,0.2)]# sigmoid 核的参数组成的列表。
        # 每个元素就是一种参数组合（依次为 gamma,coef0）
        # gamma 取值为： 0.01，0.1，0.2
        # coef0 取值为： 0.1,0.2
        # 排列组合一共有 6 种组合
    for i,(gamma,r) in enumerate(Params):
        kpca=decomposition.KernelPCA(n_components=2,kernel='sigmoid',gamma=gamma,coef0=r)
        kpca.fit(X)
        X_r=kpca.transform(X)# 原始数据集转换到二维
        ax=fig.add_subplot(3,2,i+1)## 三行两列，每个单元显示核函数为 sigmoid 的 KernelPCA 一组参数的效果图
        for label ,color in zip( np.unique(y),colors):
            position=y==label
            ax.scatter(X_r[position,0],X_r[position,1],label="target= %d"%label,
            color=color)
        ax.set_xlabel("X[0]")
        ax.set_xticks([]) # 隐藏 x 轴刻度
        ax.set_yticks([]) # 隐藏 y 轴刻度
        ax.set_ylabel("X[1]")
        ax.legend(loc="best")
        ax.set_title(r"$\tanh(%s(x\cdot z)+%s)$"%(gamma,r))
    plt.suptitle("KPCA-sigmoid")
    plt.show()
if __name__=='__main__':
    X,y=load_data() # 产生用于降维的数据集
    test_KPCA(X,y)   # 调用 test_KPCA
    #plot_KPCA(X,y)   # 调用 plot_KPCA
    #plot_KPCA_poly(X,y)   # 调用 plot_KPCA_poly
    #plot_KPCA_rbf(X,y)   # 调用 plot_KPCA_rbf
    #plot_KPCA_sigmoid(X,y)   # 调用 plot_KPCA_sigmoid

想看案例及分析，在实战的文件夹里有哦