# -*- 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]))
sklearn的简单实例演示
最新推荐文章于 2024-06-24 21:05:35 发布