Python3入门机器学习(七)- PCA

1.PCA简介

PCA(Principal Component Analysis):也是一个梯度分析的应用,不仅是机器学习的算法,也是统计学的经典算法

1-1

1.1 举个栗子

例如下面一个两个特征的一个训练集,我们可以选择一个特征,扔掉一个特征

1.1-1

下图分别是扔掉了特征一和特征二的两种方案,很明显右边这种的效果会更好一些,因为访问二扔掉特征二以后,点之间的分布情况更接近与原图,但是这不是更好的

1.1-2

我们希望有一根直线,是斜着的,我们希望将所有的点都映射到这条直线上,那么这个时候我们就成功的将二维降到了一维,与此同时,这些点更加趋近与原来的点的分布情况,换句话说,点和点之间的距离比无论是映射到x还是映射到y周,他们之间的区分度都更加的大,也就更加容易区分

1.1-3

1.2 总结

那么如何找到这个让样本间间距最大的轴? 如何定义样本间间距? 事实上有一个指标可以之间定义样本间的距离,就是方差(Variance)(方差:描述样本整体之间的疏密的一个指标,方差越大,代表样本之间越稀疏,方差越小,代表样本之间越紧密)

1.2-1:方差

1-6

第一步: 将样例的均值归为0 (demean)(归0:所有样本都减去他们的均值),使得均值为0,这样可以简化方差的公式

1.2-2

1.3 推导

1.3-1

进行均值归0操作以后,就是下面的式子

1.3-2

注:|Xproject|的平均值也是一个向量

X(i)映射到w的距离实际上就是X(i)与w的点乘(蓝色的线),根据定义推导,其值实际上就是Xproject

1.3-3

此时我们的目标函数就可以化简成

1.3-4

这是一个目标函数的最优化问题,使用梯度上升法解决。 当然我们也可以之间使用数学原理推导出结果,这里我们主要关注使用搜索的策略来求解主成分分析法,这样我们对梯度上升发和梯度下降法也可以有一个更深刻的认识

1.4 与线性回归的区别

1.4-1

1.4-2

1.主成分分析法的两个轴都是特征,线性回归y轴是目标结果值 2.主成分分析法的点是垂直于方差轴直线的,线性回归的点事垂直于x轴的


2.使用梯度上升法解决PCA问题

2-1

1.注意上面式子里的每一个(X1(i)·w1+X2(i)·w2+......Xn(i)·wn)都是一个X(i)和w的点乘,所以式子可以进一步化解, 2.化简过后可以进行向量化,即每一个∑(X(i)·w1)·X1(i) 可以看成是(X·w)这个向量的转置(本来是个行向量,转置后是1行m列的列向量)X这个矩阵(m行n列)做点乘等到的其中一项的相乘相加的结果 3.最后根据转置法则 ((AB)T=BTAT)转换成最后的结果

2-2

2-3


3.主成分PCA的实现

使用梯度上升法求解主成分

import numpy as np
import matplotlib.pyplot as plt
  • 构造一个两个样本之间有基本线性关系的数据集,可以使得我们降维的效果更加明显
X = np.empty((100,2))
X[:,0] = np.random.uniform(0.,100.,size=100)
# 0.75倍的X[:,0]加上3加上一个噪音
X[:,1] = 0.75*X[:,0]+3.+np.random.normal(0.,10.,size=100)
plt.scatter(X[:,0],X[:,1])
<matplotlib.collections.PathCollection at 0x111f2e4e0>

3-1

  • 均值归0
def demean(X):
    return X-np.mean(X,axis=0)
X_demean = deamean(X)
plt.scatter(X_demean[:,0],X_demean[:,1])
<matplotlib.collections.PathCollection at 0x111d8e438>

3-2

梯度上升法

def f(w,X):
    return np.sum((X.dot(w)**2))/len(X)
def df_math(w,X):
    return X.T.dot(X.dot(w)) * 2. /len(X)
def df_debug(w,X,epsilon=0.0001):
    res = np.empty(len(w))
    for i in range(len(w)):
        w_1 = w.copy()
        w_1[i] += epsilon
        w_2 = w.copy()
        w_2[i] -= epsilon
        res[i] = (f(w_1,X)-f(w_2,X)) / (2*epsilon)
    return res
def direction(w):
    """计算单位向量"""
    return w / np.linalg.norm(w)

def gradient_ascent(df,X,inital_w,eta,n_iters = 1e4,epsilon=1e-8):
    
    w = direction(inital_w)
    cur_iter = 0
    
    while cur_iter < n_iters:
        gradient = df(w,X)
        last_w = w
        w = w + eta * gradient
        # 注意1:每次求单位向量
        w = direction(w) 
        if abs(f(w,X)-f(last_w,X)) < epsilon:
            break
            
        cur_iter = cur_iter+1
    return w
# 初始值不能为0,因为将0带入求导公式,会发现得0,没有任何方向
# 因为对于我们的目标函数来说,w=0本身就是一个最小值点

## 注意2:不能从0向量开始
inital_w = np.random.random(X.shape[1])
eta = 0.01
# 注意3:不能使用StandardScaler标准化数据
# 因为我们本来就是要使得方差最大,而标准化的目的是使得方差为1
# 使用debug模式
gradient_ascent(df_debug,X_demean,inital_w,eta)
# 输出  array([0.75934073, 0.65069321])

# 使用math数学解
gradient_ascent(df_math,X_demean,inital_w,eta)
# 输出     array([0.75934073, 0.65069321])
w = gradient_ascent(df_math,X_demean,inital_w,eta)
plt.scatter(X_demean[:,0],X_demean[:,1])
# 这个轴就是我们求出的第一个主成分
plt.plot([0,w[0]*30],[0,w[1]*30],color='r')

3-3


4.求数据的前N个主成分

求出第一主成分以后,如何求出下一个主成分? 1.数据进行改变,将数据在第一个主成分上的分量去掉

X(i)·w = ||Xproject(i)|| 即X(i)映射到w上的值,那么||Xproject(i)||(大小) ·w(方向)就是X(i)在w上的分向量记为Xproject(i)= ||Xproject(i)|| ·w X(i)-Xproject(i)就可以实现将X样本在Xproject相应上的分量去掉,相减之后的集合意义就是讲X样本映射到了Xproject向量相垂直的一个轴上,记为X`(i) = Xproject(i)

4-1

2.在新的数据上求第一主成分 得到的X` 是X中的所有样本都去除了第一主成分上的分量得到的结果,要求第二主成分,只要在新的数据上,重新求一下第一主成分

4.1 获得前n个主成分实现

def f(w,X):
    return np.sum((X.dot(w)**2))/len(X)

def df(w,X):
    return X.T.dot(X.dot(w)) * 2. /len(X)

def direction(w):
    """计算单位向量"""
    return w / np.linalg.norm(w)

def first_componet( X,inital_w,eta,n_iters = 1e4,epsilon=1e-8):
    w = direction(inital_w)
    cur_iter = 0
    
    while cur_iter < n_iters:
        gradient = df(w,X)
        last_w = w
        w = w + eta * gradient
        # 注意1:每次求单位向量
        w = direction(w) 
        if abs(f(w,X)-f(last_w,X)) < epsilon:
            break
            
        cur_iter = cur_iter+1
    return w
inital_w = np.random.random(X.shape[1])
eta = 0.01
first_componet(X_demean,inital_w,eta)
array([0.75934077, 0.65069317])
# X2 = np.empty(X.shape)
# for i in range(len(X)):
#    X2[i] = X[i] - X[i].dot(w)*w
# 向量化,X.dot(w)为m*1的向量,reshape后变成了1*m的列向量,再乘以w(方向)就是X的每一个值在w上 的分量矩阵
X2 = X - X.dot(w).reshape(-1,1)*w
# 相减得到的样本分布几乎垂直于原来的样本分布
plt.scatter(X2[:,0],X2[:,1])

4.1-1

# 求出第二主成分
w2 = first_componet(X2,inital_w,eta)
w2
# 输出     array([-0.65068927,  0.75934411])
# 因为w和w2都是单位向量,所以他们两个点乘得到的结果就是他们夹角的cos值,
# 又因为w和w2应该是互相垂直的,所以他们夹角的cos值等于0
w.dot(w2)
# 输出5.1820671385094386e-06 几乎为0
def first_n_componet(n,X,eta = 0.01,n_iters = 1e4,epsilon = 1e-8):
    X_pca = X.copy()
    X_pca = demean(X_pca)
    
    res = []
    for i in range(n):
        initial_w = np.random.random(X_pca.shape[1])
        w = first_componet(X_pca,initial_w,eta)
        res.append(w)
        X_pca = X_pca - X_pca.dot(w).reshape(-1,1) *w
    return res
first_n_componet(2,X)
# 输出  [array([0.75934077, 0.65069316]), array([-0.65068972,  0.75934372])]

5. 高维数据向低维数据进行映射

对于一个数据集X来说,这个X有m行n列,代表有m个样本n个特征,通过我们前面学习的主成分分析法,假设我们已经求出了针对这个数据来说的前k个主成分,每一个主成分对应一个单位方向,用W来表示,W也是一个矩阵,他有k行,代表我们求出的前K个主成分,每一行有n列,代表每一个主成分的坐标轴应该是有n个元素的。这是因为我们的主成分分析法主要就是将数据从一个坐标系转化成了另外一个坐标系,原来这个坐标系有n个维度,现在这个坐标系也应该有n个维度,只不过对于转化的坐标系来说,我们取出来前k个,这k个方向更加重要。

如何将我们的样本X从n维转化成k维呢,回忆们之前学到的,对于一个X样本,与一个W进行点乘,其实就是讲一个样本映射到了w这个坐标轴,得到的模,如果讲这一个样本和这k个w分别做点乘,得到的就是这一个样本,在这k个方向上做映射后每一个方向上的大小,这k个元素合在一起,就代表这一个样本映射到新的k个轴所代表的坐标系上相应的这个样本的大小

X1分别乘以W1到Wn,得到的k个数组成的向量,就是样本1映射到Wk这个坐标系上得到的k维的向量,由于k<n,所以我们就完成了一个样本从n维到k维的映射,这个过程依次类推从样本1到样本m都这么做,我们就将m个样本都从N维映射到了k维-----其实我们就是做了一个乘法X·WT(为什么是转置呢,因为我们是拿X的每一行去和W的每一行做点乘的,但是矩阵乘法规定是拿X的每一行和W的每一列做乘法)

5-1

我们得到新的降维后的矩阵Xk以后,是可以通过和Wk想乘回复回来的,但是由于我们在降维的过程中丢失了一部分信息,这时及时回复回来也和原来的矩阵不一样了,但是这个从数据角度成立的

5-2

从高维数据向地维数据的映射

class PCA:
    
    def __init__(self,n_components):
        """初始化PCA"""
        assert n_components>=1, "n_components must be vaild"
        self.n_components = n_components
        self.components_ = None
        
    def fit(self,X,eta=0.01,n_iters=1e4):
        """获得数据集X的前n个元素"""
        assert self.n_components<=X.shape[1],\
            "n_components must be greater then the feature number of X"
        def f(w,X):
            return np.sum((X.dot(w)**2))/len(X)

        def df(w,X):
            return X.T.dot(X.dot(w)) * 2. /len(X)

        def direction(w):
            """计算单位向量"""
            return w / np.linalg.norm(w)

        def first_componet( X,inital_w,eta,n_iters = 1e4,epsilon=1e-8):
            w = direction(inital_w)
            cur_iter = 0

            while cur_iter < n_iters:
                gradient = df(w,X)
                last_w = w
                w = w + eta * gradient
                # 注意1:每次求单位向量
                w = direction(w) 
                if abs(f(w,X)-f(last_w,X)) < epsilon:
                    break

                cur_iter = cur_iter+1
            return w
        
        X_pca = demean(X)

        self.components_ = np.empty(shape=(self.n_components,X.shape[1]))
        for i in range(self.n_components):
            initial_w = np.random.random(X_pca.shape[1])
            w = first_componet(X_pca,initial_w,eta)
            self.components_[i,:] = w
            
            X_pca = X_pca - X_pca.dot(w).reshape(-1,1) *w
        return self
    
    
    def transform(self,X):
        """将给定的X映射到各个主成分分量中"""
        assert X.shape[1] == self.components_.shape[1]
        
        return X.dot(self.components_.T)
    
    def inverse_transform(self,X):
        """将给定的X反映射会原来的特征空间"""
        assert X.shape[1] == self.components_.shape[0]
        
        return X.dot(self.components_)

    def __repr__(self):
        return "PCA(n_components=%d)" % self.n_components
PCA 降维的基本原理:找到另外一个坐标系,这个坐标系每一个轴依次可以表达原来的样本他们的重要程度,也就是称为所有的主成分,我们取得前k个最重要的主成分,就可以将所有的样本映射到这k个轴上,获得一个低维的数据信息

6.sklearn中的PCA

import matplotlib.pyplot as plt
plt.scatter(X[:,0],X[:,1],color='b',alpha=0.5)
plt.scatter(X_restore[:,0],X_restore[:,1],color='r',alpha=0.5)
<matplotlib.collections.PathCollection at 0x1a1e701198>

7-1

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

加载书写识别数据集

digits = datasets.load_digits()
X = digits.data
y = digits.target
# 分割数据集
from sklearn.model_selection import train_test_split
X_train,X_test,y_train,y_test = train_test_split(X,y,random_state = 666)

使用64个维度的数据集,训练knn算法

%%time
from sklearn.neighbors import KNeighborsClassifier

knn_clf = KNeighborsClassifier()
knn_clf.fit(X_train,y_train)
CPU times: user 2.65 ms, sys: 1.46 ms, total: 4.11 ms
Wall time: 2.65 ms
knn_clf.score(X_test,y_test)
0.9866666666666667

使用PCA进行降维,然后再训练knn算法

from sklearn.decomposition import PCA

pca = PCA(n_components=2)
pca.fit(X_train)
X_train_reduction = pca.transform(X_train)
X_test_reduction = pca.transform(X_test)
%%time
knn_clf = KNeighborsClassifier()
knn_clf.fit(X_train_reduction,y_train)
CPU times: user 1.67 ms, sys: 935 µs, total: 2.61 ms
Wall time: 1.67 ms
# 从64个维度降到两个维度以后,虽然运行速度提高了,但是识别精度大大降低了
knn_clf.score(X_test_reduction,y_test)
0.6066666666666667

explained_variance_ratio_-解释方差的比例

  • 0.14566817 代表第一个主成分可以解释14%的原数据
  • 0.13735469 代表第二个主成分可以解释13%的原数据 两个主成分加起来可以解释百分之27的原数据,而其他的信息丢失了

可以使用explained_variance_ratio_这个参数来查看每个主成分所解释的原数据,来判断要取多少个主成分

pca.explained_variance_ratio_
array([0.14566817, 0.13735469])
pca = PCA(n_components=64)
pca.fit(X_train)
# 这个数据可以近乎表示每个主成分轴的重要程度
pca.explained_variance_ratio_
array([1.45668166e-01, 1.37354688e-01, 1.17777287e-01, 8.49968861e-02,
       5.86018996e-02, 5.11542945e-02, 4.26605279e-02, 3.60119663e-02,
       3.41105814e-02, 3.05407804e-02, 2.42337671e-02, 2.28700570e-02,
       1.80304649e-02, 1.79346003e-02, 1.45798298e-02, 1.42044841e-02,
       1.29961033e-02, 1.26617002e-02, 1.01728635e-02, 9.09314698e-03,
       8.85220461e-03, 7.73828332e-03, 7.60516219e-03, 7.11864860e-03,
       6.85977267e-03, 5.76411920e-03, 5.71688020e-03, 5.08255707e-03,
       4.89020776e-03, 4.34888085e-03, 3.72917505e-03, 3.57755036e-03,
       3.26989470e-03, 3.14917937e-03, 3.09269839e-03, 2.87619649e-03,
       2.50362666e-03, 2.25417403e-03, 2.20030857e-03, 1.98028746e-03,
       1.88195578e-03, 1.52769283e-03, 1.42823692e-03, 1.38003340e-03,
       1.17572392e-03, 1.07377463e-03, 9.55152460e-04, 9.00017642e-04,
       5.79162563e-04, 3.82793717e-04, 2.38328586e-04, 8.40132221e-05,
       5.60545588e-05, 5.48538930e-05, 1.08077650e-05, 4.01354717e-06,
       1.23186515e-06, 1.05783059e-06, 6.06659094e-07, 5.86686040e-07,
       1.71368535e-33, 7.44075955e-34, 7.44075955e-34, 7.15189459e-34])

绘制曲线观察取前i个主成分的时候,所能解释的原数据比例

plt.plot([i for i in range(X_train.shape[1])],
         [np.sum(pca.explained_variance_ratio_[:i+1]) for i in range(X_train.shape[1])])
[<matplotlib.lines.Line2D at 0x1a1fc6eef0>]

7-2

sklearn中的PCA算法支持传入一个小于1的数来表示我们希望能解释多少比例的主成分

pca = PCA(0.95)
pca.fit(X_train)
# 说明前28个主成分表示了百分之95的信息
pca.n_components_
28
X_train_reduction = pca.transform(X_train)
X_test_reduction = pca.transform(X_test)
%%time
knn_clf = KNeighborsClassifier()
knn_clf.fit(X_train_reduction,y_train)
CPU times: user 2.43 ms, sys: 1.21 ms, total: 3.63 ms
Wall time: 2.55 ms
# 虽然训练出来的精度丢失了一些,但是效率却大大提高了
knn_clf.score(X_test_reduction,y_test)
0.98

PCA降维到两维的意义-可以方便可视化展示,帮助人们理解

下图每个颜色代表一个数字在降维到二维空间中的分布情况 仔细观察后可以发现,很多数字的区分还是比较明细的 比如如果只是区分蓝色的数字和紫色的数字,那么使用二个维度就足够了

pca = PCA(n_components=2)
pca.fit(X)
X_reduction = pca.transform(X)
for i in range(10):
    plt.scatter(X_reduction[y==i,0],X_reduction[y==i,1],alpha=0.8)

7-3

X_train_reduction.shape
(1347, 2)
y.shape
(1797,)

7.试手MNIST数据集

1.加载MNIST数据集

import numpy as np
from sklearn.datasets import fetch_mldata
mnist = fetch_mldata("MNIST original")
X,y = mnist.data,mnist.target
X_train = np.array(X[:60000],dtype=float)
y_train = np.array(y[:60000],dtype=float)
X_test = np.array(X[60000:],dtype=float)
y_test = np.array(y[60000:],dtype=float)

2.使用KNN

sklearn 封装的KNeighborsClassifier,在fit过程中如果数据集较大,会以树结构的过程进行存储,以加快knn的预测过程,但是会导致fit过程变慢 没有进行数据归一化,是因为这里的每个维度都标示的是每个像素点的亮度,他们的尺度是相同的,这个时候比较两个样本之间的距离是有意义的

from sklearn.neighbors import KNeighborsClassifier
knn_clf = KNeighborsClassifier()
%time knn_clf.fit(X_train,y_train)

CPU times: user 31.3 s, sys: 209 ms, total: 31.5 s Wall time: 31.7 s

KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski', metric_params=None, n_jobs=1, n_neighbors=5, p=2, weights='uniform')

%time knn_clf.score(X_test,y_test)

CPU times: user 10min 41s, sys: 2.55 s, total: 10min 44s Wall time: 10min 47s

0.9688

3.PCA进行降维

from sklearn.decomposition import PCA
# 使用可以解释百分之90原数据集的主成分
pca = PCA(0.9)
pca.fit(X_train)
X_train_reduction = pca.transform(X_train)
# 从784维降到了87维,只用87维就可以解释百分之90的原数据集
X_train.shape
# (60000, 784)
X_train_reduction

(60000, 784)

X_test_reduction = pca.transform(X_test)
knn_clf = KNeighborsClassifier()
%time knn_clf.fit(X_train_reduction,y_train)

CPU times: user 352 ms, sys: 2.54 ms, total: 355 ms Wall time: 356 ms

KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski', metric_params=None, n_jobs=1, n_neighbors=5, p=2, weights='uniform')

使用PCA进行降维后的数据集进行训练,不光时间变短了,准确度也变高了 这是因为PCA的过程中,不仅仅是进行了降维,还在降维的过程中将数据包含的噪音给消除了 这使得我们可以更加好的,更加准确的拿到我们数据集对应的特征,从而使得准确率大大提高

%time knn_clf.score(X_test_reduction,y_test)

CPU times: user 1min 2s, sys: 197 ms, total: 1min 2s Wall time: 1min 2s

0.9728

8.使用PCA对数据进行降噪

1.回忆我们之前的例子

import numpy as np
import matplotlib.pyplot as plt
X = np.empty((100,2))
X[:,0] = np.random.uniform(0.,100.,size=100)
# 0.75倍的X[:,0]加上3加上一个噪音
X[:,1] = 0.75*X[:,0]+3.+np.random.normal(0.,10.,size=100)
plt.scatter(X[:,0],X[:,1],color='b',alpha=0.8)

<matplotlib.collections.PathCollection at 0x10c31e828>

[图片上传失败...(image-33bc19-1526195057139)]

现在有一个问题:这个数据集展现出来这样的结果,可是是不是有这样一种情况,这个数据集就应该是一根直线呢 换句话说,这个数据集展现的是在一根直线上下进行抖动式的分布,实际上这种抖动和这根直线本身的距离是噪音 这个噪音的产生原因可能有很多,如测量人员的粗心,测量手段有问题等等原因,都会使得我们在现实世界中采集的数据 是有噪音的

from sklearn.decomposition import PCA
pca = PCA(n_components=1)
pca.fit(X)
X_reduction = pca.transform(X)
X_restore = pca.inverse_transform(X_reduction)
plt.scatter(X_restore[:,0],X_restore[:,1],color='b',alpha=0.8)

<matplotlib.collections.PathCollection at 0x1a1437ef60>

[图片上传失败...(image-689988-1526195057140)]

我们使用PCA进行降维然后在反转回原来的维度,经过这样一个操作,可以发现此时这个数据 就成为了一条直线,比较一下这两个图,我们可以说,经过这样的操作,我们将原有数据集的噪音 给消除了 当然,在实际情况下,我们不好说X_restore就是一点噪音都没有,也不好说原数据的所有的抖动全都是 噪音,所以我们还是倾向于说从X到X_restore丢失了一些信息,不过我们丢失的信息很有可能有很大的一部分 是噪音,这也解释了为什么我们在上一节降维处理以后,反而识别率提高了

总结一句话就是:降低了维度,丢失了信息,同时也去除了一部分噪音

2.手写识别的例子

from sklearn import datasets

digits = datasets.load_digits()
X,y = digits.data,digits.target
noisy_digits = X + np.random.normal(0,4,size=X.shape)
# 获得每个标记加了噪音的10个元素,一共10个标记,公100个元素
example_digits = noisy_digits[y==0,:][:10]
for num in range(1,10):
X_num = noisy_digits[y==num,:][:10]
example_digits = np.vstack([example_digits,X_num])
example_digits.shape

(100, 64)

# 画出带噪音的图像
def plot_digits(data):
fig,axes = plt.subplots(10,10,figsize=(10,10),
subplot_kw={'xticks':[],'yticks':[]},
gridspec_kw=dict(hspace=0.1,wspace=0.1))
for i,ax in enumerate(axes.flat):
ax.imshow(data[i].reshape(8,8),
cmap='binary',
interpolation='nearest',
clim=(0,16))
plot_digits(example_digits)

[图片上传失败...(image-97e1a0-1526195057140)]

使用PCA降噪

# 实际情况下,应该多试一些数字,找到最合适的数字
pca = PCA(0.5)
pca.fit(noisy_digits)
pca.n_components_

12

components = pca.transform(noisy_digits)
filtered_digits = pca.inverse_transform(components)
plot_digits(filtered_digits)
# 相比之前,数字清楚了很多,平滑了很多,说明使用PCA进行降噪是可行的

[图片上传失败...(image-f66fd0-1526195057140)]

9.人脸识别与特征脸

1.高维数据向低维数据映射

image.png

对于W这个矩阵来说,每一行代表一个方向,第一行是最重要的方向,第二行是次重要的方向 如果将W中的每一行都看作一个样本的话,那么我们也可以说,第一行所代表的样本是最重要的那个样本,最能反应X这个矩阵原来的那个特征的样本 在人脸识别领域中,X的每一行都是人脸,而W中的每一行,相应的也可以理解为是一个人脸,就是特征脸。之所以叫特征脸就是因为,每一行都能反应原来的样本的一个重要的特征。 每一行实际上是一个主成分,他相当于表达了一部分原来的人脸数据中对应的一个特征

2.实际编程用可视化的方式观察特征脸

1.加载人脸数据库

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import fetch_lfw_people
faces = fetch_lfw_people()

Downloading LFW metadata: https://ndownloader.figshare.com/files/5976012 Downloading LFW metadata: https://ndownloader.figshare.com/files/5976009 Downloading LFW metadata: https://ndownloader.figshare.com/files/5976006 Downloading LFW data (~200MB): https://ndownloader.figshare.com/files/5976015

faces.data.shape

(13233, 2914)

# images是将我们的数据集以一个二维平面可视化的角度展现出来
# 62*47 = 2914
faces.images.shape

(13233, 62, 47)

# 随机获取36张脸
random_indexs = np.random.permutation(len(faces.data))
X = faces.data[random_indexs]
example_faces = X[:36,:]
example_faces.shape

(36, 2914)

def plot_digits(data):
fig,axes = plt.subplots(6,6,figsize=(10,10),
subplot_kw={'xticks':[],'yticks':[]},
gridspec_kw=dict(hspace=0.1,wspace=0.1))
for i,ax in enumerate(axes.flat):
ax.imshow(data[i].reshape(62,47),cmap='bone')
plot_digits(example_faces)

[图片上传失败...(image-16b244-1526195057140)]

# 每张脸对应的人名
faces.target_names

array(['AJ Cook', 'AJ Lamas', 'Aaron Eckhart', ..., 'Zumrati Juma', 'Zurab Tsereteli', 'Zydrunas Ilgauskas'], dtype='<U35')

# 说明一共包含5749个不同的人的脸
len(faces.target_names)

5749

2.特征脸

%%time
X,y = faces.data,faces.target
from sklearn.decomposition import PCA
# 使用随机的方式来求解出PCA
# 没有指定n_componets ,也就是说想求出所有的主成分
pca = PCA(svd_solver='randomized')
pca.fit(X)

CPU times: user 1min 54s, sys: 2.73 s, total: 1min 57s Wall time: 30.8 s

# 一共2914个维度,所以求出了2914个主成分
pca.components_.shape

(2914, 2914)

使用所有的主成分绘制特征脸,

可以看到排在前面的这些脸相应的比较笼统,排名第一的这张脸,告诉我们人脸大概就是这个位置,大概有这样一个轮廓 越往后,鼻子眼睛的信息就清晰了起来

通过求特征脸

  • 一方面我们可以方便直观的看出在人脸识别的过程中我们是怎么看到每一张脸相应的特征的
  • 另一方面,也可以看出来,其实每一张脸都是这些人脸的一个线性组合,而特征脸依据重要程度顺序的排在了这里
plot_digits(pca.components_[:36])

[图片上传失败...(image-bac1f-1526195057140)]

由于fetch_lfw_people这个库的人脸是分布不均匀的,有的人可能只有一张图片,有的人有几十张 通过这个方法我们可以取出至少有60张脸的人的数据 faces2 = fetch_lfw_people(min_faces_per_person=60)

X,y = faces2.data,faces2.target

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏从流域到海域

Feature Selection For Machine Learning in Python (Python机器学习中的特征选择)

Feature Selection For Machine Learning in Python 原文作者:Jason Brownlee 原文地址:http...

4356
来自专栏机器学习之旅

python开发:基于SSD下的图像内容识别(一)1.首先,先看一下我们能达到什么样的效果:2.我们需要做哪些基本的步骤:

鸽了将近有一个月的时间没有更新东西,真的不是因为我懒,主要在忙一些工作上的事情,然后就是被安装caffe环境折磨的死去活来。我本来用的上mba来搭caffe环境...

1363
来自专栏AI派

如何使用sklearn加载和下载机器学习数据集

sklearn 中提供了很多常用(或高级)的模型和算法,但是真正决定一个模型效果的最后还是取决于训练(喂养)模型时所用的数据。sklearn 中的 sklear...

7625
来自专栏小鹏的专栏

机器学习中的Bias(偏差),Error(误差),和Variance(方差)有什么区别和联系?

首先 Error = Bias + Variance + Noise Error反映的是整个模型的准确度,Bias反映的是模型在样本上的输出与真实值之间的误差...

3318
来自专栏AI科技评论

大会 | CVPR 2018论文解读:真实监控场景中的异常事件检测

AI 科技评论按:本文为上海交通大学林天威为 AI 科技评论撰写的独家稿件,未经许可不得转载。 安防作为近年最热门的计算机视觉研究落地方向,与视频分析研究有着很...

8976
来自专栏xingoo, 一个梦想做发明家的程序员

《Spark MLlib 机器学习实战》1——读后总结

1 概念 ? 2 安装 3 RDD RDD包含两种基本的类型:Transformation和Action。RDD的执行是延迟执行,只有Action算子才会触发任...

1925
来自专栏量子位

如何捕获一只彩色卓别林?黑白照片AI上色教程很友好 | 哈佛大触

1952
来自专栏python开发者

神经网络反向传播梯度计算数学原理

[神经网络]反向传播梯度计算数学原理 1 文章概述 本文通过一段来自于Pytorch官方的warm-up的例子:使用numpy来实现一个简单的神经网络。使用基本...

38413
来自专栏新智元

【深度学习自动上色,数月工作几秒完成】开源神经网络图片上色技术解析

【新智元导读】本文是作者对Reddit社区用户Amir Avni深度学习上色机器人的实现,看完本文后,你也能打造媲美大师级着色效果的自动上色神经网络应用。此外,...

6347
来自专栏人工智能头条

Keras/Python深度学习中的网格搜索超参数调优(下)

5343

扫码关注云+社区

领取腾讯云代金券