分类

手写体分类

支持向量机分类器LinearSVC

# 导入数据
%matplotlib inline
import matplotlib.pyplot as plt
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
# 从sklearn.preprocessing里导入数据标准化模块
from sklearn.preprocessing import StandardScaler
# 从sklearn.svm里导入基于线性假设的支持向量机分类器LinearSVC
from sklearn.svm import LinearSVC
# sklearn.metrics里面的classification_report模块对预测结果做更加详细的分析, 精确率，召回率，F1值
from sklearn.metrics import classification_report

digits = load_digits()
# digits.data.shape

"""
digits.data　#　元数据集
digits.target　#　标签，每个数字的真实类别
digits.images[0] # 数据总是二维数组，形状（n_samples,n_features）
"""

# 每个数据集都与标签对应，使用zip()函数构成字典
images_and_labels = list(zip(digits.images, digits.target))  
# 画图
plt.figure(figsize=(6,6))
for index, (image, label) in enumerate(images_and_labels[:4]):
    plt.subplot(2, 4, index + 1)
    plt.axis('off')
    plt.imshow(image, cmap=plt.cm.gray_r, interpolation='nearest')
    plt.title('Training:%i' % label)
    
# 随机选取75%的数据作为训练样本；其余25%的数据作为测试样本。
X_train, X_test, y_train, y_test = train_test_split(digits.data, digits.target,
                                                    test_size=0.25, random_state=33)

# 查看数据情况
# print(y_train.shape)
# print(y_test.shape)

# 对训练和测试的特征数据进行标准化
ss = StandardScaler()
X_train = ss.fit_transform(X_train)
X_test = ss.transform(X_test)

# 线性假设的支持向量机分类器LinearSVC。
lsvc = LinearSVC()
#进行模型训练
lsvc.fit(X_train, y_train)
# 利用训练好的模型对测试样本的数字类别进行预测，预测结果储存在变量y_predict中
y_predict = lsvc.predict(X_test)

# 使用模型自带的评估函数进行准确性测评。
print('Linear SVC的准确率：　{}.\n'.format(lsvc.score(X_test, y_test)))
# classification_report模块对预测分析, 精确率，召回率，F1值
print(classification_report(y_test, y_predict, target_names=digits.target_names.astype(str)))

# 预测值　画图展示　对比
images_and_predictions = list(zip(X_test,
                                  y_test, y_predict))
plt.figure()
for index, (image, target, prediction) in enumerate(images_and_predictions[-4:]):
    plt.subplot(2, 4, index + 1)
    plt.axis('off')
    plt.imshow(image.reshape((8,8)), cmap=plt.cm.gray_r, interpolation='nearest')
    plt.title('Prediction: %i - %i' % (prediction, target))

plt.tight_layout()
plt.show()

image.png

回归预测

预测的目标是连续变量

波士顿房价预测

LinearRegression

import numpy as np
# 从sklearn.datasets导入波士顿房价数据读取器
from sklearn.datasets import load_boston
# 从sklearn.model_selection 导入数据分割器
from sklearn.model_selection import train_test_split
# 从sklearn.preprocessing导入数据标准化模块
from sklearn.preprocessing import StandardScaler
#　线性回归
from sklearn.linear_model import LinearRegression
# 从sklearn.linear_model导入SGDRegressor。
from sklearn.linear_model.stochastic_gradient import SGDRegressor
# 从sklearn.metrics依次导入r2_score、mean_squared_error以及mean_absoluate_error用于回归性能的评估
from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error


# 从读取房价数据存储在变量boston中。
boston = load_boston()
# 输出数据描述。
# print(boston.DESCR)

X = boston.data
y = boston.target

# 随机采样25%的数据构建测试样本，其余作为训练样本
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=33, test_size=0.25)


# 分析回归目标值的差异 ==> 值域差异较大，需对特征进行　标准化处理
print("The max target value is", np.max(boston.target))
print("The min target value is", np.min(boston.target))
print("The average target value is", np.mean(boston.target))


# 分别初始化对特征和目标值的标准化器
ss_X = StandardScaler()
ss_y = StandardScaler()

# 分别对训练和测试数据的特征以及目标值进行标准化处理 ==> 
X_train = ss_X.fit_transform(X_train)
X_test = ss_X.transform(X_test)

#　reshape(-1,1)
y_train = ss_y.fit_transform(y_train.reshape(-1,1))
y_test = ss_y.transform(y_test.reshape(-1,1))

# 线性回归进行预测
lr = LinearRegression()
# 处理不平衡数据   提醒是要对预测输出y做出ravel()转换
lr.fit(X_train, y_train.ravel())
lr_y_predict = lr.predict(X_test)

# 打印出线性回归的模型系数值 截距: intercept_, 系数：　coef_
# coef_存放回归系数，intercept_则存放截距
print("\nintercept: ", lr.intercept_)
print("coef: ", lr.coef_)


# 使用默认配置初始化线性回归器SGDRegressor
sgdr = SGDRegressor(max_iter=5)
# 使用训练数据进行参数估计
sgdr.fit(X_train, y_train.ravel())
# 对测试数据进行回归预测
sgdr_y_predict = sgdr.predict(X_test)

# 使用LinearRegression模型自带的评估模块，并输出评估结果。
print('\nThe value of default measurement of LinearRegression is', lr.score(X_test, y_test))

# 使用r2_score模块，并输出评估结果。
print('The value of R-squared of LinearRegression is', r2_score(y_test, lr_y_predict))

# 使用mean_squared_error模块，并输出评估结果。
print('The mean squared error of LinearRegression is', 
     mean_squared_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(lr_y_predict)))

# 使用mean_absolute_error模块，并输出评估结果。
print('The mean absoluate error of LinearRegression is', 
     mean_absolute_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(lr_y_predict)))

# 使用SGDRegressor模型自带的评估模块，并输出评估结果。
print('\nThe value of default measurement of SGDRegressor is', sgdr.score(X_test, y_test))

# 使用r2_score模块，并输出评估结果。
print('The value of R-squared of SGDRegressor is', r2_score(y_test, sgdr_y_predict))

# 使用mean_squared_error模块，并输出评估结果。
print('The mean squared error of SGDRegressor is', 
     mean_squared_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(sgdr_y_predict)))

# 使用mean_absolute_error模块，并输出评估结果。
print('The mean absoluate error of SGDRegressor is', 
     mean_absolute_error(ss_y.inverse_transform(y_test), ss_y.inverse_transform(sgdr_y_predict)))


plt.scatter(lr_y_predict, y_test, s=2)
plt.plot(lr_y_predict, lr_y_predict, 'r-')
plt.plot([y.min(), y.max()], [y.min(), y.max()], 'b--', lw=4)
plt.ylabel("Predieted Price")
plt.xlabel("Real Price")
plt.show()

image.png