import numpy as np

 import pylab as pl   #画图用

 from sklearn import svm

 #随机生成两组二位数据

 np.random.seed(0)#使每次产生随机数不变

 X = np.r_[np.random.randn(20,2)-[2,2],np.random.randn(20,2)+[2,2]]#注意这里np.r_[],而不是np.r_（）我都打错了，会报错TypeError: 'RClass' object is not callable

 #np.r_是按列连接两个矩阵，就是把两矩阵上下相加，要求列数相等，np.c_是按行连接两个矩阵，就是把两矩阵左右相加，要求行数相等

 Y = [0] * 20+[1] * 20#Python原来可以这么简单的创建重复的列表呀

 clf=svm.SVC(kernel='linear')

 clf.fit(X,Y)

 w=clf.coef_[0]

 a=-w[0]/w[1]

 xx=np.linspace(-5,5)#产生-5到5的线性连续值，间隔为1

 yy=a*xx-(clf.intercept_[0])/w[1]  #clf.intercept_[0]是w3.即为公式a1*x1+a2*x2+w3中的w3。(clf.intercept_[0])/w[1]即为直线的截距

 #得出支持向量的方程

 b=clf.support_vectors_[0]

 yy_down=a*xx+(b[1]-a*b[0])#(b[1]-a*b[0])就是简单的算截距

 b=clf.support_vectors_[-1]

 yy_up=a*xx+(b[1]-a*b[0])

 print("w:",w) #打印出权重系数

 print("a:",a) #打印出斜率

 print("suport_vectors_:",clf.support_vectors_)#打印出支持向量

 print("clf.coef_:",clf.coef_)                  #打印出权重系数，还是w

 #这个就是画出来而已。很简单，也不太常用，都用matplotlib去了。不多说了

 pl.plot(xx,yy,'k-')

 pl.plot(xx,yy_down,'k--')

 pl.plot(xx,yy_up,'k--')

 pl.scatter(clf.support_vectors_[:,0],clf.support_vectors_[:,0],s=80,facecolors='none')

 pl.scatter(X[:,0],X[:,1],c=Y,cmap=pl.cm.Paired)

 pl.axis('tight')

 pl.show()

 #from __future__ import print_function #__future__模块，把下一个新版本的特性导入到当前版本，于是我们就可以在当前版本中测试一些新版本的特性

                                         #我的Python版本是3.6.4.所以不需要这个

 from time import time   #对程序运行时间计时用的

 import logging           #打印程序进展日志用的

 import matplotlib.pyplot as plt  #绘图用的

 from sklearn.model_selection import train_test_split

 from sklearn.datasets import fetch_lfw_people

 from sklearn.model_selection import GridSearchCV

 from sklearn.metrics import classification_report

 from sklearn.metrics import confusion_matrix

 from sklearn.decomposition import PCA

 from sklearn.svm import SVC

 logging.basicConfig(level=logging.INFO,format='%(asctime)s %(message)s')

 lfw_people=fetch_lfw_people(min_faces_per_person=70,resize=0.4)  #名人的人脸数据集、

 n_samples,h,w=lfw_people.images.shape  #多少个实例，h,w高度，宽度值

 X=lfw_people.data   #特征向量矩阵

 n_feature=X.shape[1]#每个人有多少个特征值

 Y=lfw_people.target

 target_names=lfw_people.target_names

 n_classes=target_names.shape[0]     #多少类

 print("Total dataset size")

 print("n_samples:",n_samples)

 print("n_feature:",n_feature)

 print("n_classes:",n_classes)

 X_train,X_test,Y_train,Y_test=train_test_split(X,Y,test_size=0.25)  #选取0.25的测试集

 #降维

 n_components=150  #PCA算法中所要保留的主成分个数n，也即保留下来的特征个数n

 print("Extracting the top %d eigenfaces from %d faces" % (n_components,X_train.shape[0]))

 t0=time()

 pca=PCA(svd_solver='randomized',n_components=n_components,whiten=True).fit(X_train)#训练一个pca模型

 print("Train PCA in %0.3fs" % (time()-t0))

 eigenfaces  = pca.components_.reshape((n_components,h,w))  #提取出来特征值之后的矩阵

 print("Prijecting the input data on the eigenfaces orthonarmal basis")

 t0=time()

 X_train_pca = pca.transform(X_train)     #将训练集与测试集降维

 X_test_pca = pca.transform(X_test)

 print("Done PCA in %0.3fs" % (time()-t0))

 #终于到SVM训练了

 print("Fiting the classifier to the training set")

 t0=time()

 param_grid ={'C':[1e3,5e3,1e4,5e4,1e5],#C是对错误的惩罚

              'gamma':[0.0001,0.0005,0.001,0.005,0.01,0.1],}#gamma核函数里多少个特征点会被使用}#对参数尝试不同的值

 clf = GridSearchCV(SVC(kernel='rbf'),param_grid)

 clf=clf.fit(X_train_pca,Y_train)

 print("Done Fiting in %0.3fs" % (time()-t0))

 print("Best estimotor found by grid search:")

 print(clf.best_estimator_)

 print("Predicting people's names on the test set")

 t0=time()

 Y_pred = clf.predict(X_test_pca)

 print("done Predicting in %0.3fs" % (time()-t0))

 print(classification_report(Y_test,Y_pred,target_names=target_names)) #生成一个小报告呀

 print(confusion_matrix(Y_test,Y_pred,labels=range(n_classes)))#这个也是，生成的矩阵的意思是有多少个被分为此类。

 #把分类完的图画出来12个。

 #这个函数就是画图的

 def plot_gallery(images,titles,h,w,n_row=3,n_col=4):

     plt.figure(figsize=(1.8*n_col,2.4*n_row))

     plt.subplots_adjust(bottom=0,left=.01,right=.99,top=.90,hspace=.35)

     for i in range(n_row*n_col):

         plt.subplot(n_row,n_col,i+1)

         plt.imshow(images[i].reshape((h,w)),cmap=plt.cm.gray)

         plt.title(titles[i],size=12)

         plt.xticks(())

         plt.yticks(())

 #这个函数是生成一个固定格式的字符串的

 def title(y_pred,y_test,target_names,i):

     pred_name=target_names[y_pred[i]].rsplit(' ',1)[-1]

     true_name = target_names[y_test[i]].rsplit(' ', 1)[-1]

     return "predicted: %s\n true: %s" %(pred_name,true_name)

 predicted_titles=[title(Y_pred,Y_test,target_names,i) for i in range(Y_pred.shape[0])] #这个for循环的用法很简介

 plot_gallery(X_test,predicted_titles,h,w)

 eigenfaces_titles=["eigenface %d " % i for i in range(eigenfaces.shape[0])]

 plot_gallery(eigenfaces,eigenfaces_titles,h,w)

 plt.show()

'''

看他的官方文档

def fetch_lfw_people(data_home=None, funneled=True, resize=0.5,

                     min_faces_per_person=0, color=False,

                     slice_=(slice(70, 195), slice(78, 172)),

                     download_if_missing=True):

    """Loader for the Labeled Faces in the Wild (LFW) people dataset

    This dataset is a collection of JPEG pictures of famous people

    collected on the internet, all details are available on the

    official website:

        http://vis-www.cs.umass.edu/lfw/

    Each picture is centered on a single face. Each pixel of each channel

    (color in RGB) is encoded by a float in range 0.0 - 1.0.

   The task is called Face Recognition (or Identification): given the

    picture of a face, find the name of the person given a training set

    (gallery).

The original images are 250 x 250 pixels, but the default slice and resize

    arguments reduce them to 62 x 74.

    Parameters

    ----------

    data_home : optional, default: None

        Specify another download and cache folder for the datasets. By default

        all scikit learn data is stored in '~/scikit_learn_data' subfolders.

    funneled : boolean, optional, default: True

        Download and use the funneled variant of the dataset.

    resize : float, optional, default 0.5

        Ratio used to resize the each face picture.

    min_faces_per_person : int, optional, default None

        The extracted dataset will only retain pictures of people that have at

       least `min_faces_per_person` different pictures.

    color : boolean, optional, default False

        Keep the 3 RGB channels instead of averaging them to a single

        gray level channel. If color is True the shape of the data has

        one more dimension than the shape with color = False.

    slice_ : optional

        Provide a custom 2D slice (height, width) to extract the

        'interesting' part of the jpeg files and avoid use statistical

        correlation from the background

    download_if_missing : optional, True by default

        If False, raise a IOError if the data is not locally available

       instead of trying to download the data from the source site.

    Returns

    -------

   dataset : dict-like object with the following attributes:

    dataset.data : numpy array of shape (13233, 2914)

        Each row corresponds to a ravelled face image of original size 62 x 47

        pixels. Changing the ``slice_`` or resize parameters will change the

        shape of the output.

    dataset.images : numpy array of shape (13233, 62, 47)

        Each row is a face image corresponding to one of the 5749 people in

       the dataset. Changing the ``slice_`` or resize parameters will change

        the shape of the output.

    dataset.target : numpy array of shape (13233,)

       Labels associated to each face image. Those labels range from 0-5748

       and correspond to the person IDs.

   dataset.DESCR : string

       Description of the Labeled Faces in the Wild (LFW) dataset

意思就是min_faces_per_person=定义了每个人取多少个不同图片,resize=重新定义了图片的大小

'''

'''

n_components:PCA算法中所要保留的主成分个数n，也即保留下来的特征个数n

类型：int 或者 string，缺省时默认为None，所有成分被保留。

          赋值为int，比如n_components=1，将把原始数据降到一个维度。

          赋值为string，比如n_components='mle'，将自动选取特征个数n，使得满足所要求的方差百分比。

copy:表示是否在运行算法时，将原始训练数据复制一份。若为True，则运行PCA算法后，原始训练数据的值不会有任何改变，因为是在原始数据的副本上进行运算；若为False，则运行PCA算法后，原始训练数据的值会改，因为是在原始数据上进行降维计算。

类型：bool，True或者False，缺省时默认为True。

whiten:白化，使得每个特征具有相同的方差。由于图像中相邻像素之间具有很强的相关性，所以用于训练时输入是冗余的。白化的目的就是降低输入的冗余性；更正式的说，我们希望通过白化过程使得学习算法的输入具有如下性质：(i)特征之间相关性较低；(ii)所有特征具有相同的方差。

类型：bool，缺省时默认为False

PCA对象的属性

components_ ：返回具有最大方差的成分。

explained_variance_ratio_：返回 所保留的n个成分各自的方差百分比。

n_components_：返回所保留的成分个数n。

mean_：

noise_variance_：

'''