import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import sklearn.datasets as sd
iris = sd.load_iris()
iris.keys()
"""
dict_keys(['data', 'target', 'frame', 'target_names', 'DESCR', 'feature_names', 'filename', 'data_module'])
"""
print(iris.DESCR)
"""
.. _iris_dataset:
Iris plants dataset
--------------------
**Data Set Characteristics:**
# 样本数量：150，每个类别有50个样本
:Number of Instances: 150 (50 in each of three classes)
# 属性数量：4列
:Number of Attributes: 4 numeric, predictive attributes and the class
:Attribute Information:
# 萼片长度，宽度
- sepal length in cm
- sepal width in cm
# 花瓣长度，宽度
- petal length in cm
- petal width in cm
- class:
- Iris-Setosa
- Iris-Versicolour
- Iris-Virginica
:Summary Statistics:
============== ==== ==== ======= ===== ====================
Min Max Mean SD Class Correlation
============== ==== ==== ======= ===== ====================
sepal length: 4.3 7.9 5.84 0.83 0.7826
sepal width: 2.0 4.4 3.05 0.43 -0.4194
petal length: 1.0 6.9 3.76 1.76 0.9490 (high!)
petal width: 0.1 2.5 1.20 0.76 0.9565 (high!)
============== ==== ==== ======= ===== ====================
:Missing Attribute Values: None
:Class Distribution: 33.3% for each of 3 classes.
:Creator: R.A. Fisher
:Donor: Michael Marshall (MARSHALL%PLU@io.arc.nasa.gov)
:Date: July, 1988
The famous Iris database, first used by Sir R.A. Fisher. The dataset is taken
from Fisher's paper. Note that it's the same as in R, but not as in the UCI
Machine Learning Repository, which has two wrong data points.
This is perhaps the best known database to be found in the
pattern recognition literature. Fisher's paper is a classic in the field and
is referenced frequently to this day. (See Duda & Hart, for example.) The
data set contains 3 classes of 50 instances each, where each class refers to a
type of iris plant. One class is linearly separable from the other 2; the
latter are NOT linearly separable from each other.
.. topic:: References
- Fisher, R.A. "The use of multiple measurements in taxonomic problems"
Annual Eugenics, 7, Part II, 179-188 (1936); also in "Contributions to
Mathematical Statistics" (John Wiley, NY, 1950).
- Duda, R.O., & Hart, P.E. (1973) Pattern Classification and Scene Analysis.
(Q327.D83) John Wiley & Sons. ISBN 0-471-22361-1. See page 218.
- Dasarathy, B.V. (1980) "Nosing Around the Neighborhood: A New System
Structure and Classification Rule for Recognition in Partially Exposed
Environments". IEEE Transactions on Pattern Analysis and Machine
Intelligence, Vol. PAMI-2, No. 1, 67-71.
- Gates, G.W. (1972) "The Reduced Nearest Neighbor Rule". IEEE Transactions
on Information Theory, May 1972, 431-433.
- See also: 1988 MLC Proceedings, 54-64. Cheeseman et al"s AUTOCLASS II
conceptual clustering system finds 3 classes in the data.
- Many, many more ...
"""
iris.target_names # 类别
"""
array(['setosa', 'versicolor', 'virginica'], dtype='<U10')
"""
iris.feature_names # 特征名称
"""
['sepal length (cm)',
'sepal width (cm)',
'petal length (cm)',
'petal width (cm)']
"""
data = pd.DataFrame(iris.data, columns=iris.feature_names)
data['target'] = iris.target
data
# 基于透视表完成简单数据统计分析
data.pivot_table(index='target')
"""
petal length (cm) petal width (cm) sepal length (cm) sepal width (cm)
target
0 1.462 0.246 5.006 3.428
1 4.260 1.326 5.936 2.770
2 5.552 2.026 6.588 2.974
"""
# 可视化 花瓣的长和宽
data.plot.scatter(x='petal length (cm)', y='petal width (cm)', c='target', cmap='brg', s=20) # cmap 颜色映射 s 调节点大小
# 可视化 萼片的长和宽
data.plot.scatter(x='sepal length (cm)', y='sepal width (cm)', c='target', cmap='brg', s=20) # cmap 颜色映射 s 调节点大小
| 姓名 | 成绩 | 分类 |
|---|---|---|
| Jerry | 86 | 1 |
| Tom | 98 | 1 |
| Lily | 58 | 0 |
| …… | …… | …… |
t = w T x + b \quad t=w^Tx+b t=wTx+b
对于回归问题，可以使用均方差作为损失函数，对于分类问题，如何度量预测值与真实值之间的差异？分类问题采用交叉熵作为损失函数，当只有两个类别时，交叉熵表达式为：
E
(
y
,
y
^
)
=
−
[
y
l
o
g
(
y
^
)
+
(
1
−
y
)
l
o
g
(
1
−
y
^
)
]
E(y, \hat{y}) = -[y \ log(\hat{y}) + (1-y)log(1-\hat{y})]
E(y,y^)=−[y log(y^)+(1−y)log(1−y^)]
其中，y为真实值， y ^ \hat{y} y^为预测值.
import sklearn.linear_model as lm
"""
构建逻辑回归器
solver: 用来指明损失函数的优化方法，sklearn自带了如下几种：
liblinear:坐标轴下降法来迭代优化损失函数
newton-cg:牛顿法的一种
lbfgs:拟牛顿法
sag:随机平均梯度下降（适合样本量大的情况）
penalty: 参数可选择的值为"l1"和"l2".与solver有关。
如果是L2正则化，所有优化算法都可用。
如果是L1正则化，只能使用“liblinear”。
C：该参数可以控制正则强度，值越小正则强度越大，可以防止过拟合。
model = lm.LogisticRegression(solver='liblinear', C=正则强度)
model.fit(训练输入集, 训练输出集)
result = model.predict(带预测输入集)
"""
# 创建模型
# solver参数：逻辑函数中指数的函数关系（liblinear表示线性关系）
# C参数：正则强度，越大拟合效果越小，通过调整该参数防止过拟合
model = lm.LogisticRegression(solver='liblinear', C=1)
# 训练
model.fit(x, y)
# 预测
pred_y = model.predict(x)
import sklearn.model_selection as ms
import sklearn.linear_model as lm
# 整理输入集输出集，拆分测试集训练集
x, y = sub_data.iloc[:,:-1], sub_data['target']
# 训练模型
train_x, test_x, train_y, test_y = ms.train_test_split(x, y, test_size=0.1, random_state=7)
model = lm.LogisticRegression()
model.fit(train_x, train_y)
# 评估 模型准确率
pred_test_y = model.predict(test_x)
"""
pred_test_y, test_y.values
(array([1, 1, 2, 2, 1, 1, 2, 2, 2, 1]), array([1, 1, 2, 2, 1, 1, 2, 2, 2, 1]))
print(pred_test_y==test_y)
87 True
76 True
128 True
141 True
99 True
65 True
143 True
121 True
136 True
72 True
Name: target, dtype: bool
"""
print((pred_test_y==test_y).sum() / test_y.size)
# 1.0
| 特征1 | 特征2 | ==> | A模型 | B模型 | C模型 |
|---|---|---|---|---|---|
| 4 | 7 | ==> | 0.7 | 0.1 | 0.2 |
| 3.5 | 8 | ==> | 0.8 | 0.1 | 0.1 |
| 1.2 | 1.9 | ==> | 0.1 | 0.6 | 0.3 |
| 5.4 | 2.2 | ==> | 0.2 | 0.1 | 0.7 |
| 特征1 | 特征2 | 特征3 | 实际类别 |
|---|---|---|---|
| x 1 x_1 x1 | x 2 x_2 x2 | x 3 x_3 x3 | A |
| x 1 x_1 x1 | x 2 x_2 x2 | x 3 x_3 x3 | B |
| x 1 x_1 x1 | x 2 x_2 x2 | x 3 x_3 x3 | C |
进行以下多次分类，得到结果：
第一次：分为A类（值为1）和非A类（值为0）
第二次：分为B类（值为1）和非B类（值为0）
第三次：分为C类（值为1）和非C类（值为0）
利用逻辑分类器实现多元分类示例代码如下：
# 多元分类器示例
import numpy as np
import sklearn.linear_model as lm
import matplotlib.pyplot as mp
# 输入
x = np.array([[4, 7],
[3.5, 8],
[3.1, 6.2],
[0.5, 1],
[1, 2],
[1.2, 1.9],
[6, 2],
[5.7, 1.5],
[5.4, 2.2]])
# 输出（多个类别）
y = np.array([0, 0, 0, 1, 1, 1, 2, 2, 2])
# 创建逻辑分类器对象
model = lm.LogisticRegression(C=200) # 调整该值为1看效果
model.fit(x, y) # 训练
# 坐标轴范围
left = x[:, 0].min() - 1
right = x[:, 0].max() + 1
h = 0.005
buttom = x[:, 1].min() - 1
top = x[:, 1].max() + 1
v = 0.005
grid_x, grid_y = np.meshgrid(np.arange(left, right, h),
np.arange(buttom, top, v))
mesh_x = np.column_stack((grid_x.ravel(), grid_y.ravel()))
mesh_z = model.predict(mesh_x)
mesh_z = mesh_z.reshape(grid_x.shape)
# 可视化
mp.figure('Logistic Classification', facecolor='lightgray')
mp.title('Logistic Classification', fontsize=20)
mp.xlabel('x', fontsize=14)
mp.ylabel('y', fontsize=14)
mp.tick_params(labelsize=10)
mp.pcolormesh(grid_x, grid_y, mesh_z, cmap='gray')
mp.scatter(x[:, 0], x[:, 1], c=y, cmap='brg', s=80)
mp.show()
import sklearn.model_selection as ms
import sklearn.linear_model as lm
# 整理输入集输出集，拆分测试集训练集
x, y = data.iloc[:,:-1], data['target']
# 训练模型
train_x, test_x, train_y, test_y = ms.train_test_split(x, y, test_size=0.1, random_state=7)
model = lm.LogisticRegression()
model.fit(train_x, train_y)
# 评估 模型准确率
pred_test_y = model.predict(test_x)
print((pred_test_y==test_y).sum() / test_y.size)
# 0.8666666666666667
1）逻辑回归是分类问题，用于实现二分类问题
2）实现方式：利用线性模型计算，在逻辑函数作用下产生分类
3）多分类实现：可以将多分类问题转化为二分类问题实现
4）用途：广泛用于各种分类问题
import sklearn.model_selection as ms
训练输入，测试输入，训练输出，测试输出 = \
ms.train_test_split(
x, y, test_size=0.1, random_state=7,
stratify=y)
import sklearn.model_selection as ms
import sklearn.linear_model as lm
# 整理输入集输出集，拆分测试集训练集
x, y = data.iloc[:,:-1], data['target']
# 训练模型
train_x, test_x, train_y, test_y = ms.train_test_split(x, y, test_size=0.1, random_state=7, stratify=y)
model = lm.LogisticRegression()
model.fit(train_x, train_y)
# 评估 模型准确率
pred_test_y = model.predict(test_x)
print((pred_test_y==test_y).sum() / test_y.size)
print(test_y.values)
"""
1.0
[2 0 0 1 0 2 2 2 1 1 2 1 1 0 0]
"""
import sklearn.model_selection as ms
指标性数组 = \
ms.cross_val_score(模型,输入集,输出集,cv=折叠数,scoring=指标名)
import sklearn.model_selection as ms
import sklearn.linear_model as lm
# 整理输入集输出集，拆分测试集训练集
x, y = data.iloc[:,:-1], data['target']
# 训练模型
train_x, test_x, train_y, test_y = ms.train_test_split(x, y, test_size=0.1, random_state=7, stratify=y)
model = lm.LogisticRegression()
# 做5次交叉验证
scores = ms.cross_val_score(model, x, y, cv=5, scoring='accuracy')
scores.mean()
"""
0.9733333333333334
"""
model.fit(train_x, train_y)
# 评估 模型准确率
pred_test_y = model.predict(test_x)
print((pred_test_y==test_y).sum() / test_y.size)
print(test_y.values)
"""
1.0
[2 0 0 1 0 2 2 2 1 1 2 1 1 0 0]
"""
import sklearn.model_selection as ms
import sklearn.linear_model as lm
# 整理输入集输出集，拆分测试集训练集
x, y = data.iloc[:,:-1], data['target']
# 训练模型
train_x, test_x, train_y, test_y = ms.train_test_split(x, y, test_size=0.1, random_state=7, stratify=y)
model = lm.LogisticRegression()
# 做5次交叉验证
scores = ms.cross_val_score(model, x, y, cv=5, scoring='accuracy')
print(scores.mean())
scores = ms.cross_val_score(model, x, y, cv=5, scoring='precision_weighted')
print(scores.mean())
scores = ms.cross_val_score(model, x, y, cv=5, scoring='recall_weighted')
print(scores.mean())
scores = ms.cross_val_score(model, x, y, cv=5, scoring='f1_weighted')
print(scores.mean())
"""
0.9733333333333334
0.9767676767676768
0.9733333333333334
0.973165236323131
"""
| A类别 | B类别 | C类别 | |
|---|---|---|---|
| A类别 | 3 | 1 | 1 |
| B类别 | 0 | 4 | 2 |
| C类别 | 0 | 0 | 7 |
| A类别 | B类别 | C类别 | |
|---|---|---|---|
| A类别 | 5 | 0 | 0 |
| B类别 | 0 | 6 | 0 |
| C类别 | 0 | 0 | 7 |
import sklearn.metrics as sm
混淆矩阵 = sm.confusion_matrix(实际输出, 预测输出)
import sklearn.metrics as sm
m = sm.confusion_matrix(test_y, pred_test_y)
print(m)
"""
[[5 0 0]
[0 5 0]
[0 0 5]]
"""
plt.imshow(m, cmap='gray')
# 获取分类报告
cr = sm.classification_report(实际输出，预测输出)
print(cr)
"""
precision recall f1-score support
0 1.00 1.00 1.00 5
1 1.00 1.00 1.00 5
2 1.00 1.00 1.00 5
accuracy 1.00 15
macro avg 1.00 1.00 1.00 15
weighted avg 1.00 1.00 1.00 15
"""