sklearn的简单实例演示

# -*- coding: utf-8 -*-
"""
Created on Mon May 14 09:29:49 2018

@author: Loulch C.C
"""

"""
sklearn 的数据集有好多个种类:
1. 自带的小数据集（packaged dataset）：sklearn.datasets.load_<name>
2. 可在线下载的数据集（Downloaded Dataset）：sklearn.datasets.fetch_<name>
3. 计算机生成的数据集（Generated Dataset）：sklearn.datasets.make_<name>
4. svmlight/libsvm格式的数据集:sklearn.datasets.load_svmlight_file(...)
5. 从买了data.org在线下载获取的数据集:sklearn.datasets.fetch_mldata(...)
"""

"""
自带的小数据集（packaged dataset）：
鸢尾花数据集load_iris(用于多分类任务的简单数据集)
#http://scikit-learn.org/stable/auto_examples/datasets/plot_iris_dataset.html
手写数字数据集load_digits(用于多分类任务的简单数据集)
乳腺癌数据集load-barest-cancer（简单经典的用于二分类任务的数据集）
糖尿病数据集：load-diabetes（经典的用于回归任务的数据集，值得注意的是， 
            这10个特征中的每个特征都已经被处理成0均值，方差归一化的特征值，）
波士顿房价数据集：load-boston（经典的用于回归任务的数据集）
体能训练数据集：load-linnerud（经典的用于多变量回归任务的数据集，
           其内部包含两个小数据集：Excise是对3个训练变量的20次观测（体重，腰围，脉搏），
           physiological是对3个生理学变量的20次观测（引体向上，仰卧起坐，立定跳远））
"""
import numpy as np

#鸢尾花数据集load_iris:用于多分类任务的简单数据集
#该数据集由3种不同类型的鸢尾花(Setosa, Versicolour, and Virginica)的花瓣和萼片长度，
#存储在一个150 x4 NuPy.nDAREL中。行为样本；列为萼片长度，萼片宽度，花瓣长度和花瓣宽度。

from sklearn.datasets import load_iris

#下面有些处理数据的过程并没有多大作用，但可以帮助了解一些基本函数
iris=load_iris()#加载数据集
#print(iris.keys())　　
#dict_keys(['data', 'target', 'target_names', 'DESCR', 'feature_names'])

n_samples,n_features=np.shape(iris.data)     #数据的样本个数和特征数
print("Number of sample:",n_samples)         #Number of sample: 150
print("Number of feature:",n_features)       #Number of feature 4
print(iris.data[0])             #第一个样例[ 5.1  3.5  1.4  0.2]
print(iris.data.shape)          #(150, 4)
print(iris.target)
"""
#输出：target
　　[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
　　0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
　　1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2
　　2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
　　2 2]
"""
print(iris.target.shape)        #(150,)
print(iris.target_names)        #['setosa' 'versicolor' 'virginica']
print(iris.DESCR)               #description缩写，关于数据集的一个描述
print(iris.feature_names)
#['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']
np.bincount(iris.target)        #[50 50 50]
#np.bincount计数非负整数数组中每个值的出现次数。 

import matplotlib.pyplot as plt

#以索引值为3的列为划分依据画直方图，x_index的值可以为0，1，2，3，其实就是data的第几个列
x_index=3
colors=['blue','red','green']
for label,color in zip(range(len(iris.target_names)),colors):
    plt.hist(iris.data[iris.target==label,x_index],label=iris.target_names[label],color=color)
#zip()返回一个zip对象，该对象的__next__()方法返回一个元组，其中第i个元素来自第i个可迭代的参数。
#__next__()方法继续，直到参数序列中最短的迭代被耗尽，然后增加停止迭代。
#iris.data[iris.target==label,x_index]，用数组过滤将x_index列且满足条件
#iris.target==label的元素挑出来   
#plt.hist()画直方图    
plt.xlabel(iris.feature_names[x_index])
plt.ylabel('numbers of iris')
plt.legend(loc="upper right")           #设置图例
plt.show()

#画散点图，第一列的数据作为x轴和第二列的数据作为y轴
x_index=0
y_index=1
colors=['blue','red','green']
#分3步画
for label,color in zip(range(len(iris.target_names)),colors):
    plt.scatter(iris.data[iris.target==label,x_index],
                iris.data[iris.target==label,y_index],
                label=iris.target_names[label],
                c=color)
plt.xlabel(iris.feature_names[x_index])
plt.ylabel(iris.feature_names[y_index])
plt.legend(loc='best')
plt.show()
#上述过程只是简单的画了一下图分析了一下数据，并没有起多大作用。

from sklearn.neighbors import KNeighborsClassifier 
from sklearn.model_selection import train_test_split

#准备数据
iris_X=iris.data
iris_y=iris.target
X_train,X_test,y_train,y_test=train_test_split(iris_X,iris_y,test_size=0.3,
                                               random_state=4)
print(y_train)    #可以看出在分离训练集和测试集是随机打乱了顺序
#[2 0 1 2 1 0 1 2 1 2 1 2 1 2 0 2 1 0 0 2 1 1 0 0 1 2 0 2 0 0 0 0 2 1 0 2 1
# 2 0 0 0 2 1 0 1 1 0 1 2 0 0 1 2 2 1 2 0 2 2 2 0 1 2 2 2 1 0 1 2 2 1 1 0 1
# 1 1 2 1 0 0 2 1 2 0 1 1 1 0 0 2 1 1 0 1 0 0 2 1 0 0 1 0 1 0 1]
#训练算法
knn=KNeighborsClassifier(n_neighbors=5)
knn.fit(X_train,y_train)   #返回训练好的knn
#测试算法
print(knn.predict(X_test))
#[0 2 1 2 2 1 0 0 1 2 2 0 0 1 1 0 2 2 2 2 2 0 2 0 2 0 2 0 1 2 0 2 2 2 1 1 1
# 2 1 0 2 2 0 0 2]
print(y_test)
#[0 1 1 2 1 1 0 0 1 2 2 0 0 1 1 0 2 2 2 2 2 0 2 0 2 0 2 0 1 2 0 2 2 2 1 1 1
# 2 1 0 2 2 0 0 2]
print(knn.score(X_test,y_test))   #0.9777777777777777

r=len(knn.predict(X_test))
error=0
for i in range(r):
    if knn.predict(X_test)[i]!=y_test[i]:
        error+=1
print('number of errors is %.d'% error)
#number of errors is 2,说明预测错了2个数据

#下面进行多次交叉验证，进行更好的改进
from sklearn.cross_validation import cross_val_score

scores=cross_val_score(knn,iris_X,iris_y,cv=5,scoring='accuracy')
print(scores)
#[0.96666667 1.         0.93333333 0.96666667 1.        ]
print(scores.mean())    #0.9733333333333334
#这个结果更加准确

#下面挑选KNN合适的
k_range=range(1,31)
k_scores=[]
for k in k_range:
    knn=KNeighborsClassifier(n_neighbors=k)
    scores=cross_val_score(knn,iris_X,iris_y,cv=10,scoring='accuracy')
    #for classification
    #loss=-cross_val_score(knn,iris_X,iris_y,cv=10,scoring='neg_mean_squared_error')
    #for regression
    k_scores.append(scores.mean())
    
plt.plot(k_range,k_scores)
plt.xlabel('value of K for KNN')
plt.ylabel('loss of cross_validation')
plt.show()

#手写数据集load_digits
from sklearn.datasets import load_digits
digits=load_digits()
print(digits.data.shape)        #(1797, 64)
#画图
plt.gray()#将默认色图设置为灰色，如果有的话，应用于当前图像。 
plt.matshow(digits.images[0])
plt.show()

#print(digits.keys())
#dict_keys(['data', 'target', 'target_names', 'images', 'DESCR'])
n_samples,n_features=digits.data.shape
print(digits.target.size)        #1797
print(np.bincount(digits.target))#[178 182 177 183 181 182 181 179 174 180]
print(np.bincount(digits.target_names))#[1 1 1 1 1 1 1 1 1 1]
print(digits.images.shape)       #(1797, 8, 8),1797张大小为8*8的图片
print(np.all(digits.images.reshape((1797,64))==digits.data))#True
#np.all()测试沿着给定轴的所有数组元素是否为true。（NAN和非零数返回True）

fig=plt.figure(figsize=(7,7))
fig.subplots_adjust(left=0,right=1,bottom=0,top=1,hspace=0.05,wspace=0.05)
#绘制数字：每张图像8*8像素点
for i in range(64):
    ax=fig.add_subplot(8,8,i+1,xticks=[],yticks=[])
    ax.imshow(digits.images[i],cmap=plt.cm.binary,interpolation='nearest')
    #用目标值标记图像 
    ax.text(0,7,str(digits.target[i]))#在每个子图(0,7)的位置添加文本。
plt.show()

from sklearn.model_selection import learning_curve   #学习曲线
from sklearn.svm import SVC

X=digits.data
y=digits.target
train_sizes, train_loss, test_loss = learning_curve(SVC(gamma=0.001), X, y,
        scoring='neg_mean_squared_error',cv=10,train_sizes=[0.1,0.25,0.5,0.75,1.0])
#换成gamma=0.01，学习效果并不好
train_loss_mean=-np.mean(train_loss,axis=1)
test_loss_mean=-np.mean(test_loss,axis=1)

plt.plot(train_sizes,train_loss_mean,'o-',color='r',label='training')
plt.plot(train_sizes,test_loss_mean,'o-',color='g',label='cross_validation')
plt.xlabel('train_size')
plt.ylabel('loss')
plt.legend(loc='best')
plt.show()

from sklearn.model_selection import validation_curve   #验证曲线

digits=load_digits()
X=digits.data
y=digits.target
param_range=np.logspace(-6,-2.3,5) 
#在对数刻度(-6,-2.3)上,均匀的返回5个数字。
train_scores, test_scores = validation_curve(SVC(), X, y, param_name="gamma",
                                              param_range=param_range,cv=10,
                                              scoring='neg_mean_squared_error')
train_loss_mean=-np.mean(train_loss,axis=1)
test_loss_mean=-np.mean(test_loss,axis=1)

plt.plot(param_range,train_loss_mean,'o-',color='r',label='training')
plt.plot(param_range,test_loss_mean,'o-',color='g',label='cross_validation')
plt.xlabel('gamma')
plt.ylabel('loss')
plt.legend(loc='best')
plt.show()


#波士顿房价的数据集load_boston：经典的用于回归任务的数据集

from sklearn.datasets import load_boston
from sklearn.linear_model import LinearRegression

#来导入sklearn提供的波士顿房价的数据
loaded_data = load_boston()
X_data = loaded_data.data           #data存储特征矩阵
y_data = loaded_data.target         #target存储类别标签
model = LinearRegression()          #模型用线性回归哟
model.fit(X_data,y_data)            #model.fit训练模型
print(model.coef_)                  #每个特征的权重/系数
#[-1.07170557e-01  4.63952195e-02  2.08602395e-02  2.68856140e+00
# -1.77957587e+01  3.80475246e+00  7.51061703e-04 -1.47575880e+00
#  3.05655038e -01 -1.23293463e-02 -9.53463555e-01  9.39251272e-03
# -5.25466633e-01]
print(model.intercept_)             #偏置
#36.491103280361955

#这里直接拿训练集前面4个，并预测，只用于简单演示
print(model.predict(X_data[:4,:]))
#[30.00821269 25.0298606  30.5702317  28.60814055]
print(y_data[:4])
#[24.  21.6 34.7 33.4]

print(model.score(X_data,y_data))   #coefficient of determination R^2/
#R^2决定系数来判断 回归方程 拟合的程度.
#0.7406077428649427

print(model.get_params)            #查看之前的参数设置
#<bound method BaseEstimator.get_params of LinearRegression(copy_X=True, 
#fit_intercept=True, n_jobs=1, normalize=False)>

#Sklearn还允许我们自己生成一些数据

from sklearn.datasets import make_regression

X,y = make_regression(n_samples=100,n_features=1,n_targets=1,noise=1)
#随机生成，有100个样本，特征一个，目标变量一个，噪声noise=1

#画X，y的散点图咯
plt.scatter(X,y)
plt.show()

#把噪声noise变大点，会更加离散，例如noise=10
X,y = make_regression(n_samples=100,n_features=1,n_targets=1,noise=10)
plt.scatter(X,y)
plt.show()

#下面来点有用的，利用svm将生成的数据进行分类
from sklearn import preprocessing
from sklearn.datasets.samples_generator import make_classification
from sklearn.svm import SVC

X,y = make_classification(n_samples=300,n_features=2,n_informative=2,n_redundant=0,
                          n_repeated=0,n_classes=2,random_state=1,n_clusters_per_class=1,
                          scale=100)
#画图,可视化数据
plt.scatter(X[:,0],X[:,1],c=y)
plt.show()

X=preprocessing.scale(X)   #.scale(X) 对X进行归一化，normalization
#preprocessing.minmax_scale(X, feature_range=(0, 1), axis=0, copy=True)
#Transforms features by scaling each feature to a given range.
X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=3)
svc=SVC()        #svm是支持向量机
svc.fit(X_train,y_train)
print(svc.score(X_test,y_test))      #1.0
#注释掉X=preprocessing.scale(X) ，svc.score(X_test,y_test)返回0.3333333333333333
#由于随机生成，上述结果可能不同

#模型保存
from  sklearn import svm
from  sklearn import datasets

iris = datasets.load_iris()
clf =svm.SVC()
X,y=iris.data,iris.target
clf.fit(X,y)

#方法一：pickle
import  pickle

with open('clf.pickle','wb') as f:
    pickle.dump(clf,f)
    
with open('clf.pickle','rb') as f:
    clf_save=pickle.load(f)
    print(clf_save.predict(X[0:1]))
    
#方法二：joblib,与pickle神似，但有区别
from sklearn.externals import joblib

#保存
joblib.dump(clf,'save\clf.pic')
#提取
joblib.load('save\clf.pic')
print(clf_save.predict(X[0:1]))