Sklearn调用处理
01降维处理
1.1PCA处理
1.1.1API讲解
调用方式
sklearn.decomposition.PCA(ncomponents=None, copy=True, whiten=False, svdsolver='auto', tol=0.0, iteratedpower='auto', randomstate=None)
参数释义
n_components：PCA 算法中所要保留的主成分个数 n，也即保留下来的特征个数 n
int 或者 string，缺省时默认为 None，所有成分被保留。赋值为 int，比如=1，将把原始数据降到一个维度 赋值为 string，比如’mle’，将自动选取特征个数 n，使得满足所要求的方差百分比
whiten：白化，使得每个特征具有相同的方差。
bool，缺省时默认为 False 如果 PCA 降维后有后续的数据处理动作，可以考虑白化
svd_solver：定奇异值分解 SVD 的方法
auto PCA 类自动选择下述三种算法权衡
-
randomized
-
适用于数据量大，数据维度多同时主成分数目比例又较低的 PCA 降维
-
full
-
传统意义上的 SVD，使用了 scipy 库对应的实现
-
arpack
-
直接使用 scipy 库的 sparse SVD 实现，和 randomized 的适用场景类似
copy：表示是否在运行算法时，将原始训练数据复制一份。
若为 True，则运行 PCA 算法后，原始训练数据的值不会有任何改变，因为是在原始数据的副本上进行运算；若为 False，则运行 PCA 算法后，原始训练数据的值会改，因为是在原始数据上进行降维计算。
tol：停止求解的标准，float 类型，默认值为 0 当 svd_solver 选择‘arpack’时，其运行 SVD 算法的容错率
iterated_power：int 类型或者 str 类型，默认值为‘auto’ 当 svd_solver 选择‘randomized’时，其运行 SVD 算法的的迭代次数
random_state：int 类型，默认为 None 伪随机数发生器的种子,在混洗数据时用于概率估计
属性
components_
返回具有最大方差的成分
explainedvariance
降维后的各主成分的方差值。方差值越大，则说明越是重要的主成分
explainedvarianceratio_
降维后的各主成分的方差值占总方差值的比例，这个比例越大，则越是重要的主成分
singularvalues
对应的每个成分的奇异值
mean_
根据训练集估算的特征经验均值=X.mean（axis = 0）
ncomponents
返回所保留的成分个数n
nfeatures
训练数据的特征个数
nsamples
训练数据的样本数
noisevariance
返回噪声的协方差
函数
fit(self, X[, y])
用数据X来训练PCA模型
fit_transform(self, X[, y])
用X来训练PCA模型，同时返回降维后的数据
get_covariance(self)
计算数据协方差（ 用生成模型）
get_params(self[, deep])
获取PCA的参数
get_precision(self)
计算数据精度矩阵（ 用生成模型）
inverse_transform(self, X)
将降维后的数据转换成原始数据，但可能不会完全一样
score(self, X[, y])
计算所有样本的log似然平均值
score_samples(self, X)
返回每个样本的对数似然值
set_params(self, **params)
设置PCA的参数
transform(self, X)
将数据X转换成降维后的数据，当模型训练好后，对于新输入的数据，也可以用transform方法来降维
1.1.2常用API操作演示
代码演示
from sklearn.decomposition import PCA
import pandas as pd
# 获取iris数据集
df = pd.read_csv(r'datas/iris.txt')
# 获取特征
x = df.iloc[:, :-1]
# 创建PCA模型，降维到二维数据
model = PCA(n_components=2)
# 拟合数据并执行
x = model.fit_transform(x)
print('打印降维后前5行的数据信息:')
print(x[:5])
print('各成分方差值占总方差值的比例:')
print(model.explained_variance_ratio_)
显示结果：
打印降维后前5行的数据信息:
[[-2.73363445 -0.16331092]
[-2.90803676 -0.13076902]
[-2.76491784 -0.30475856]
[-2.7461081 0.34027983]
[-2.29679724 0.75348469]]
各成分方差值占总方差值的比例:
[0.92395437 0.05343362]
1.2SVD
1.2.1API讲解
调用方式
class sklearn.decomposition.TruncatedSVD(n_components=2, algorithm=’randomized’, n_iter=5, random_state=None, tol=0.0)
参数释义
n_components：目标输出维度，必须少于特征维数，默认数据是为了可视化；对于LSA推荐100
int缺省时默认为2，降维到2维
algorithm：SVD求解用，arpack或者randomized
string, default = “randomized”
n_iter：randomized SVD solver的迭代次数，ARPACK不可用
int, optional (default 5)
random_state：随机种子
intrandom_state是随机数发生器，None：np.random采用的RandomState实例
tol：ARPACK的公差
0：machine precision，randomized SVD solver忽略
属性
components_
SVD算法中所要保留的主成分个数 n，也即保留下来的特征个数 n
explained_variance_
降维后的各主成分的方差值。方差值越大，则说明越是重要的主成分
explained_variance_ratio_
降维后的各主成分的方差值占总方差值的比例，这个比例越大，则越是重要的主成分
singular_values_
显示选定维度的奇异值
函数
fit(self, X[, y])
拟合数据
fit_transform(self, X[, y])
将SVD模型与X进行拟合，并对X进行降维。
get_params(self[, deep])
获取SVD的参数
inverse_transform(self, X)
将降维后的数据转换成原始数据，但可能不会完全一样
set_params(self, **params)
设置SVD参数
transform(self, X)
将数据X转换成降维后的数据，当模型训练好后，对于新输入的数据，也可以用transform方法来降维
1.2.2常用API操作演示
代码演示
from sklearn.decomposition import TruncatedSVD
import pandas as pd
# 获取iris数据集
df = pd.read_csv(r'datas/iris.txt')
# 获取特征
x = df.iloc[:, :-1]
# 创建SVD模型
model = TruncatedSVD(n_components=2)
# 拟合数据并执行
x = model.fit_transform(x)
print('打印降维后前5行的数据信息:')
print(x[:5])
print('各成分方差值占总方差值的比例:')
print(model.explained_variance_ratio_)
显示结果：
打印降维后前5行的数据信息:
[[5.5690361 1.98238953]
[5.44325676 2.10489891]
[5.43313694 1.88003274]
[5.87147945 2.33837351]
[6.47340943 2.33547564]]
各成分方差值占总方差值的比例:
[0.53274157 0.44414728]
02数据预处理
2.1归一化
2.1.1API讲解
调用方式
sklearn.preprocessing.MinMaxScaler(feature_range=(0, 1), copy=True)
参数释义
feature_range：确定参数最大值，最小值范围
填写int数据类型
copy:数据插入规范
布尔值，可选，默认为真，设置为False以执行插入行规范化并避免a
属性
min_
缩放后最小值调整大小
scale_
每个特征相对缩放量
data_min_
数据中的最小值
data_max_
数据中的最大值
data_range_
数据范围
函数
fit(self, X, y=None)
计算用于以后缩放的最小值和最大值。
partial_fit(self, X, y=None)
在线计算X上的最小值和最大值，方便以后缩放。
transform(self, X)
根据最值缩放特征
inverse_transform(self, X)
根据最值，撤销缩放，返回原数据
fit_transform(self, X, y=None)
将模型与数据进行拟合，并对X进行归一化处理。
2.1.2常用API演示
代码演示
import numpy as np
from sklearn.preprocessing import MinMaxScaler
a = np.array([
[2104, 3],
[1600, 3],
[2400, 3],
[1416, 2],
[3000, 4],
[1985, 4]
])
# 创建模型
model = MinMaxScaler()
# 拟合并运行数据
x = model.fit_transform(a)
print('归一化后效果：')
print(x)
print('数据最小值：{}'.format(model.data_min_))
print('原数据：')
print(model.inverse_transform(x))
显示结果：
归一化后效果：
[[0.43434343 0.5 ]
[0.11616162 0.5 ]
[0.62121212 0.5 ]
[0. 0. ]
[1. 1. ]
[0.35921717 1. ]]
数据最小值：[1416. 2.]
原数据：
[[2.104e+03 3.000e+00]
[1.600e+03 3.000e+00]
[2.400e+03 3.000e+00]
[1.416e+03 2.000e+00]
[3.000e+03 4.000e+00]
[1.985e+03 4.000e+00]]
2.2规范化
2.2.1API讲解
调用方式
sklearn.preprocessing.StandardScaler(copy=True, with_mean=True, with_std=True)
参数释义
copy:transform的时候是否需要进行进行备份，不修改原数据
True，将原数据进行备份
with_mean：如果是，则在扩展之前将数据居中。在尝试执行时，此操作不工作(并将引发异常)稀疏矩阵，因为集中它们需要建立一个稠密矩阵在一般用例中可能太大而无法放入的矩阵内存。
with_std:如果是，将数据缩放到单位方差(或相等，单位标准差)。
属性
scale_
每个特征数据的相对缩放
mean_
每个特征的均值
var_
每个特征的方差
n_samples_seen_
估计器为每个特征处理的样本数量
函数
fit(self, X, y=None)
计算用于以后缩放的最小值和最大值。
partial_fit(self, X, y=None)
在线计算X上的最小值和最大值，方便以后缩放。
transform(self, X)
根据最值缩放特征
inverse_transform(self, X)
根据最值，撤销缩放，返回原数据
fit_transform(self, X, y=None)
将模型与数据进行拟合，并对X进行标准化处理。
2.2.2常用API操作演示
代码演示
import numpy as np
from sklearn.preprocessing import StandardScaler
a = np.array([
[2104, 3],
[1600, 3],
[2400, 3],
[1416, 2],
[3000, 4],
[1985, 4]
])
model = StandardScaler()
x = model.fit_transform(a)
print('缩放后的结果：')
print(x)
print('每个特征的缩放比例:{}'.format(model.scale_))
print('每个特征的均值:{}'.format(model.mean_))
print('每个特征的方差:{}'.format(model.var_))
显示结果：
缩放后的结果：
[[ 0.03805676 -0.24253563]
[-0.92903261 -0.24253563]
[ 0.60602988 -0.24253563]
[-1.28209698 -1.69774938]
[ 1.75732674 1.21267813]
[-0.19028379 1.21267813]]
每个特征的缩放比例:[521.15142287 0.68718427]
每个特征的均值:[2084.16666667 3.16666667]
每个特征的方差:[2.71598806e+05 4.72222222e-01]
2.3标签化
2.3.1API讲解
调用方式
sklearn.preprocessing.LabelEncoder()
函数
fit(y)
fit可看做一本空字典，y可看作要塞到字典中的词。
fit_transform(y)
相当于先进行fit再进行transform，即把y塞到字典中去以后再进行transform得到索引值。
inverse_transform(y)
根据索引值y获得原始数据。
transform(y)
将y转变成标签值。
2.3.2常用API操作演示
代码演示
from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
# 拟合数据
le.fit(["paris", "paris", "tokyo", "amsterdam"])
# 翻译数据
print(le.transform(["tokyo", "tokyo", "paris"]))
# 显示数据原始状态
print(list(le.inverse_transform([2, 2, 1])))
显示结果：
[2 2 1]
['tokyo', 'tokyo', 'paris']
2.4独热编码
2.4.1API讲解
调用方式
sklearn.preprocessing.OneHotEncoder(n_values=None, categorical_features=None,
categories=None, drop=None, sparse=True, dtype=np.float64,
handle_unknown='error')
参数释义
n_values:表示每个特征使用几维的数值由数据集自动推断，即几种类别就使用几位来表示。（scikit-learn 0.20 中以categories替代，也即： categories=’auto’ ）
一般不做调整
categorical_features：可能取值为all、indices数组或mask
- 若为all时，代表所有的特征都被视为分类特征
- 若为indices数组时，表示分类特征的indices值
- 若mask时，表示特征长度数组
drop:用于从每个特征中舍去特定的分类
默认为None，且不能与categories、n_values同用
sparse:表示编码的格式
默认为 True，即为稀疏的格式，指定 False 则就不用 toarray() 了
dtype:表示编码数值格式
默认为浮点型
handle_unknown：即如果碰到未知的类别，是返回一个错误还是忽略它
其值可以指定为 “error” 或者 “ignore”
属性
n_values_
取每个特征的最大特征值+1
feature_indices_
n_values_的累计
函数
fit(X, y=None)
拟合数据
transform(X)
将x转化为OneHot形式
fit_transform(X, y=None)
拟合x数据，并将它转化为OneHot形式
inverse_transform(X)
将返回的数据转换为原始表示形式
get_feature_names(input_features=None)
返回输出特性的特性名称
2.4.2常用API操作演示
代码演示
from sklearn.preprocessing import OneHotEncoder
label = [[1], [2], [1], [3]]
model = OneHotEncoder(sparse=False)
onehot = model.fit_transform(label)
print('独热后效果：')
print(onehot)
print('返回原始数据：')
print(model.inverse_transform(onehot))
显示结果：
独热后效果：
[[1. 0. 0.]
[0. 1. 0.]
[1. 0. 0.]
[0. 0. 1.]]
返回原始数据：
[[1.]
[2.]
[1.]
[3.]]
2.5数据二值化
2.5.1API讲解
调用方式
sklearn.preprocessing.Binarize(threshold=0.0, copy=True)
参数释义
threshold：阈值(通过阈值判断结果的0,1)
浮点数
copy:transform的时候是否需要进行进行备份，不修改原数据
True，将原数据进行备份
函数
fit(X, y=None)
拟合数据
transform(X)
将x转化为二值化形式
fit_transform(X, y=None)
拟合x数据，并将它转化为二值化形式
2.5.2常用API操作演示
代码演示
from sklearn.preprocessing import Binarizer
a = [[3], [5], [1], [4]]
model = Binarizer(threshold=3.5)
x = model.fit_transform(a)
print('二值化后结果')
print(x)
显示结果：
二值化后结果
[[0]
[1]
[0]
[1]]
2.6多项式处理
2.6.1API讲解
调用方式
sklearn.preprocessing.PolynomialFeatures(degree=2, interaction_only=False, include_bias=True)
参数释义
degree：多项式次数(就同几元几次方程中的次数一样)
填写整数
interaction_only：是否包含单个自变量**n(n>1)特征数据标识
True 不包含单个自变量**n(n>1)
include_bias：是否包含偏差标识
boolean类型数值
属性
powers_
powers_[i, j]是第i个输出中的第j个输入的指数。
n_input_features_
输入特征总数
n_output_features_
输出特征总数
函数
get_feature_names(input_features=None)
获取特征名称
fit(X, y=None)
拟合数据
transform(X)
将x转化为多项式形式
fit_transform(X, y=None)
拟合x数据，并将它转化为多项式形式
2.6.2常用API操作演示
代码演示
from sklearn.preprocessing import PolynomialFeatures
import numpy as np
X = np.arange(6).reshape(3, 2)
print('默认方式运行')
ploy = PolynomialFeatures(degree = 2)
print(ploy.fit_transform(X))
print(ploy.get_feature_names())
print('--------------------------------')
print('不包含单个自变量**n(n>1)特征数据标识')
ploy = PolynomialFeatures(degree = 2 , interaction_only = True)
print(ploy.fit_transform(X))
print(ploy.get_feature_names())
print('--------------------------------')
print('不设置截距项')
ploy = PolynomialFeatures(degree = 2 , interaction_only = True,include_bias= False)
print(ploy.fit_transform(X))
print(ploy.get_feature_names())
输出结果：
默认方式运行
[[ 1. 0. 1. 0. 0. 1.]
[ 1. 2. 3. 4. 6. 9.]
[ 1. 4. 5. 16. 20. 25.]]
['1', 'x0', 'x1', 'x0^2', 'x0 x1', 'x1^2']
--------------------------------
不包含单个自变量**n(n>1)特征数据标识
[[ 1. 0. 1. 0.]
[ 1. 2. 3. 6.]
[ 1. 4. 5. 20.]]
['1', 'x0', 'x1', 'x0 x1']
--------------------------------
设置截距项
[[ 0. 1. 0.]
[ 2. 3. 6.]
[ 4. 5. 20.]]
['x0', 'x1', 'x0 x1']
2.7管道机制
2.7.1API讲解
调用方式
sklearn.pipeline.Pipeline(steps, memory = None, verbose = False)
参数释义
steps:设定工序并取名
形式: [(),()] 列表里面为元组, 分别为名字和工序
memory:是否执行缓存
默认不要调整
verbose:显示流水线所消耗的时间
默认False不显示
函数
fit_transform()
拟合并执行
get_params()
获取参数
predict()
预测结果值
2.7.2常用API操作演示
代码演示
from sklearn.preprocessing import MinMaxScaler
from sklearn.linear_model import LinearRegression
from sklearn.pipeline import Pipeline
x = [[1], [2], [3]]
y = [[1.1], [2.11], [3.09]]
# 先执行归一化操作，再执行线性回归
model = Pipeline([('mms', MinMaxScaler()), ('linear', LinearRegression())])
model.fit(x, y)
print(model.predict(x))
显示结果：
[[1.105]
[2.1 ]
[3.095]]
03linear_model相关算法
3.1线性模型
3.1.1API讲解
调用方式
sklearn.linear_model.LinearRegression(fit_intercept=True, normalize=False, copy_X=True, n_jobs=None)
参数释义
fit_intercept:拟合截距
True代表创建截距
normalize:当’ ’ fit_intercept ’ '设置为False时，将忽略此参数。
若为真，则回归前对回归量X进行归一化处理，减去平均值，然后除以l2-范数。如果您希望标准化，请使用
copy_X:如果为真，则复制X;否则，它可能被覆盖
n_jobs:要用于计算的作业数。这只会提供，加速n_targets > 1和足够大的问题
一般不修改
属性
coef_
权重
intercept_
截距
函数
fit(X, y, sample_weight=None)
拟合线性模型
sample_weight设置样本权重
predict(X)
预测线性模型
score(X, y, sample_weight=None)
模型评分R方
3.1.2常用API操作演示
代码演示
from sklearn.linear_model import LinearRegression
x = [[1], [2], [3]]
y = [[1.1], [2.11], [3.09]]
model = LinearRegression(fit_intercept=True)
# 拟合截距
model.fit(x, y)
print('预测结果：{}'.format(model.predict(x)))
print('得分结果：{}'.format(model.score(x, y)))
print('截距：{}'.format(model.intercept_))
print('权重：{}'.format(model.coef_))
显示结果：
预测结果：[[1.105]
[2.1 ]
[3.095]]
得分结果：0.9999242500757499
截距：[0.11]
权重：[[0.995]]
3.2Lasso回归
3.2.1API讲解
调用方式
sklearn.linear_model.Lasso(alpha=1.0, fit_intercept=True, normalize=False, precompute=False, copy_X=True, max_iter=1000, tol=0.0001, warm_start=False, positive=False, random_state=None, selection='cyclic')
参数释义
alpha: 正则化强度，默认为 1.0。
fit_intercept: 默认为 True，计算截距项。
normalize: 默认为 False，不针对数据进行标准化处理。
precompute: 是否使用预先计算的 Gram 矩阵来加速计算。
copy_X: 默认为 True，即使用数据的副本进行操作，防止影响原数据。
max_iter: 最大迭代次数，默认为 1000。
tol: 数据解算精度。
warm_start: 重用先前调用的解决方案以适合初始化。
positive: 强制系数为正值。
random_state: 随机数发生器。
selection: 每次迭代都会更新一个随机系数。
属性
coef_
权重
intercept_
截距
函数
fit(X, y, sample_weight=None)
拟合线性模型
sample_weight设置样本权重
predict(X)
预测线性模型
score(X, y, sample_weight=None)
模型评分R方
3.3Ridge回归
3.3.1API讲解
调用方式
sklearn.linear_model.Ridge(alpha=1.0, fit_intercept=True, normalize=False, copy_X=True, max_iter=None, tol=0.001, solver=’auto’, random_state=None)
参数释义
alpha:正则化强度; 必须是正浮点数，默认值为1
copy_X：boolean，可选，默认为True如果为True，将复制X; 否则，它可能被覆盖
fit_intercept： boolean是否计算此模型的截距。 如果设置为false，则不会在计算中使用截距
max_iter： int，可选共轭梯度求解器的最大迭代次数。 对于’sparse_cg’和’lsqr’求解器，默认值由scipy.sparse.linalg确定。 对于’sag’求解器，默认值为1000。
normalize： boolean，可选，默认为False如果为真，则回归X将在回归之前被归一化。 当fit_intercept设置为False时，将忽略此参数。 当回归量归一化时，注意到这使得超参数学习更加鲁棒，并且几乎不依赖于样本的数量。 相同的属性对标准化数据无效。 然而，如果你想标准化，请在调用normalize = False训练估计器之前，使用preprocessing.StandardScaler处理数据
solver：{‘auto’，‘svd’，‘cholesky’，‘lsqr’，‘sparse_cg’，‘sag’}
-
'auto’根据数据类型自动选择求解器。
-
'svd’使用X的奇异值分解来计算Ridge系数。对于奇异矩阵比’cholesky’更稳定。
-
'cholesky’使用标准的scipy.linalg.solve函数来获得闭合形式的解。
-
'sparse_cg’使用在scipy.sparse.linalg.cg中找到的共轭梯度求解器。作为迭代算法，这个求解器比大规模数据（设置tol和max_iter的可能性）的“cholesky”更合适。
-
'lsqr’使用专用的正则化最小二乘常数scipy.sparse.linalg.lsqr。它是最快的，但可能不是在旧的scipy版本可用。它还使用迭代过程。
-
'sag’使用随机平均梯度下降。它也使用迭代过程，并且当n_samples和n_feature都很大时，通常比其他求解器更快。注意，“sag”快速收敛仅在具有近似相同尺度的特征上被保证。您可以使用sklearn.preprocessing的缩放器预处理数据。
tol：float解的精度
random_state:伪随机数生成器的种子，当混洗数据时使用。 仅用于’sag’求解器
属性
coef_
权重
intercept_
截距
函数
fit(X, y, sample_weight=None)
拟合线性模型
sample_weight设置样本权重
predict(X)
预测线性模型
score(X, y, sample_weight=None)
模型评分R方
3.4逻辑回归
3.4.1API讲解
调用方式
class sklearn.linear_model.LogisticRegression(penalty=’l2’, dual=False, tol=0.0001, C=1.0, fit_intercept=True, intercept_scaling=1, class_weight=None, random_state=None, solver=’warn’, max_iter=100, multi_class=’warn’, verbose=0, warm_start=False, n_jobs=None, l1_ratio=None)
参数释义
penalty：惩罚项，可为’l1’ or ‘l2’。‘netton-cg’, ‘sag’, ‘lbfgs’只支持’l2’
dual：选择目标函数为原始形式还是对偶形式。
tol：优化算法停止的条件。当迭代前后的函数差值小于等于tol时就停止。
C：正则化系数。其越小，正则化越强。正则化系数的倒数
fit_intercept：选择逻辑回归模型中是否会有常数项b
class_weight：用于标示分类模型中各种类型的权重，{class_label: weight} or ‘balanced’
random_state：随机数种子。
solver：逻辑回归损失函数的优化方法
- ‘liblinear’：使用坐标轴下降法来迭代优化损失函数。
- ‘lbfgs’：拟牛顿法的一种。利用损失函数二阶导数矩阵即海森矩阵来迭代优化损失函数。
- ‘newton-cg’：牛顿法的一种。同上。
- ‘sag’：随机平均梯度下降。每次迭代仅仅用一部分的样本来计算梯度，适合于样本数据多的时候。
max_iter：优化算法的迭代次数
verbose：控制是否print训练过程
n_jobs：用cpu的几个核来跑程序
属性
classes：训练集中所有类标签组成的列表。
coef：权重
intercept_：二分类就只有一个，多分类就会有n个
n_iter_:实际上迭代次数，即达到收敛时的迭代次数
函数
fit(X,y,sample_weight=None)
把数据放入模型中训练模型，其中sample_weight=None是array类型可以对训练集中实例添加权重，即对训练集中不同的数据增加不同的权重。
predict(X)：
预测样本X的分类类别
predict_lot_proba(X)：
返回样本X在各个类别上对应的对数概率
predict_proba(X)：
返回样本X在各个类别上对应的概率
score(X,y[,sample_weight])：
模型准确率
3.4.2常用API操作演示
代码演示
from sklearn.linear_model import LogisticRegression
import warnings
warnings.filterwarnings('ignore')
x = [[1, 2],
[2, 3],
[3, 1],
[4, 3],
[5, 3],
[6, 2]]
y = [[0],
[0],
[0],
[1],
[1],
[1]]
# 正则化系数0.5，l2正则
model = LogisticRegression(C=2, penalty='l2')
model.fit(x, y)
print('模型预测结果：', model.predict(x))
print('模型权重：', model.coef_)
print('模型截距：', model.intercept_)
print('模型准确率：', model.score(x, y))
显示结果：
模型预测结果： [0 0 1 1 1 1]
模型权重： [[ 0.65986921 -0.33149819]]
模型截距： [-1.06973278]
模型准确率： 0.8333333333333334
04K近邻算法
4.1回归处理
4.1.1API讲解
调用方式
sklearn.neighbors.KNeighborsRegressor(n_neighbors=5,weights=’uniform’,algorithm=’auto’,leaf_size=30,p=2, metric=’minkowski’,metric_params=None,n_jobs=1,**kwargs)
参数释义
n_neighbors：选取的K值数，默认为5
weights：用于预测结果的权重值取值方式
- ‘uniform’ : 所有近邻点样本权重相同
- ‘distance’ :样本点的权重是相距距离的倒数
- [callable] :自定义权重方式
algorithm：采用的策略算法
- ‘ball_tree’：采用球树方式计算
- ‘kd_tree’: 采用KD树方式计算
- ‘brute’: 采用蛮力法计算
- ‘auto’：会采用最优方式进行计算
leaf_size：叶节点数量，只能使用在KD树，球树上
p：默认值为2，代表使用欧式距离计算；1代表曼哈顿距离
metric：度量方式，默认是‘minkowski’闵可夫斯基距离
n_jobs：设定算法并行运行数量
属性
weights：权重使用方式
algorithm：使用的算法类型
n_neighbors：设置的近邻数量
函数
fit(X,y)
把数据放入模型中训练模型
predict(X)
预测样本X的回归值
score(X,y)
模型评分R方
kneighbors([X,n_neighbors,return_distance])
返回输入样本的相邻点和距离
kneighbors_graph([X,n_neighbors,mode])
为X中的点计算k近邻的(加权)图
4.1.2常用API操作演示
代码演示
from sklearn.neighbors import KNeighborsRegressor
import numpy as np
T = np.array([
[3, 104, 98],
[2, 100, 93],
[1, 81, 95],
[101, 10, 16],
[99, 5, 8],
[98, 2, 7]
])
x = T[:,:-1]
y = T[:, -1]
knn = KNeighborsRegressor(n_neighbors=3)# 取最近的三个样本
knn.fit(x, y)
print('判断预测结果：\n', knn.predict(x))
print('模型R方：', knn.score(x, y))
显示结果：
判断预测结果：
[95.33333333 95.33333333 95.33333333 10.33333333 10.33333333 10.33333333]
模型R方： 0.9943724863517504
4.2分类处理
4.2.1API讲解
调用方式
sklearn.neighbors.KNeighborsClassifier(n_neighbors=5, weights=’uniform’, algorithm=’auto’, leaf_size=30,p=2, metric=’minkowski’, metric_params=None, n_jobs=1, **kwargs)
参数释义
n_neighbors：选取的K值数，默认为5
weights：用于预测结果的权重值取值方式
- ‘uniform’ : 所有近邻点样本权重相同
- ‘distance’ :样本点的权重是相距距离的倒数
- [callable] :自定义权重方式
algorithm：采用的策略算法
- ‘ball_tree’：采用球树方式计算
- ‘kd_tree’: 采用KD树方式计算
- ‘brute’: 采用蛮力法计算
- ‘auto’：会采用最优方式进行计算
leaf_size：叶节点数量，只能使用在KD树，球树上
p：默认值为2，代表使用欧式距离计算；1代表曼哈顿距离
metric：度量方式，默认是‘minkowski’闵可夫斯基距离
n_jobs：设定算法并行运行数量
属性
weights：权重使用方式
algorithm：使用的算法类型
n_neighbors：设置的近邻数量
函数
fit(X,y)
把数据放入模型中训练模型
predict(X)
预测样本X的分类结果
predict_proba(x)
预测样本X的分类概率
score(X,y)
模型评分准确率
kneighbors([X,n_neighbors,return_distance])
返回输入样本的相邻点和距离
kneighbors_graph([X,n_neighbors,mode])
为X中的点计算k近邻的(加权)图
4.2.2常用API操作演示
代码演示
from sklearn.neighbors import KNeighborsClassifier
import numpy as np
T = np.array([
[3, 104, 0],
[2, 100, 0],
[1, 81, 0],
[101, 10, 1],
[99, 5, 1],
[98, 2, 1]
])
x = T[:,:-1]
y = T[:, -1]
knn = KNeighborsClassifier(n_neighbors=3)# 取最近的三个样本
knn.fit(x, y)
print('判断预测结果：\n', knn.predict(x))
print('预测结果概率：\n', knn.predict_proba(x))
print('模型准确率：', knn.score(x, y))
显示结果：
判断预测结果：
[0 0 0 1 1 1]
预测结果概率：
[[1. 0.]
[1. 0.]
[1. 0.]
[0. 1.]
[0. 1.]
[0. 1.]]
模型准确率： 1.0
05朴素贝叶斯
5.1高斯贝叶斯
5.1.1API讲解
调用方式
sklearn.naive_bayes.GaussianNB(priors=None, var_smoothing=1e-09)
参数释义
priors: 类的先验概率。如果指定，则不根据数据调整先验。
var_smoothing: 最大方差部分的所有特征，是增加到方差计算的稳定性。
属性
class_count_：每次观察样本数量
class_prior_：样本每种类别的可能性
classes_：真实类别
epsilon_：方差的绝对加值
sigma_：每个类别内的差异，标准差
theta_：每个类别的均值
函数
fit(X, y[, sample_weight])
训练高斯贝叶斯算法
predict(X)
根据x预测样本类别
predict_log_proba(X)
返回测试向量X的对数概率估计值
predict_proba(X)
测试向量X的返回概率估计测试向量X的返回概率估计
score(X, y[, sample_weight])
返回数据得分，准确率
5.1.2常用API操作演示
代码演示
from sklearn.naive_bayes import GaussianNB
from sklearn.datasets import load_iris
# 读取数据集，并切分特征和标签
data = load_iris()
x = data.data
y = data.target
model = GaussianNB()
model.fit(x, y)
print('模型预测结果：\n', model.predict(x)) # 打印预测结果
print('样本每种类别可能性：\n', model.predict_proba(x)[:10])# 打印前10个数据
显示结果：
模型预测结果：
[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 2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 1 1 1
1 1 1 2 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 1 2 2 2 2
2 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2
2 2]
样本每种类别可能性：
[[1.00000000e+00 1.35784265e-18 7.11283512e-26]
[1.00000000e+00 1.51480769e-17 2.34820051e-25]
[1.00000000e+00 1.07304179e-18 2.34026774e-26]
[1.00000000e+00 1.46619543e-17 2.95492722e-25]
[1.00000000e+00 4.53291917e-19 2.88389975e-26]
[1.00000000e+00 1.49094245e-14 1.75752068e-21]
[1.00000000e+00 1.10262691e-17 2.71144689e-25]
[1.00000000e+00 6.53644612e-18 2.77336308e-25]
[1.00000000e+00 9.42227052e-18 1.20443161e-25]
[1.00000000e+00 3.42348334e-18 1.20750647e-25]]
5.2多项式贝叶斯
5.2.1API详解
调用方式
sklearn.naive_bayes.MultinomialNB(alpha=1.0, fit_prior=True, class_prior=None)
参数释义
alpha：拉普拉斯平滑系数
fit_prior：是否学习类先验概率。如果为假，则使用统一的先验。
class_prior：类的先验概率。如果指定，则不根据数据调整先验。
属性
class_count_：拟合过程中遇到的每个类的样本数。该值由提供的样本重量加权。
class_log_prior_：平滑的经验对数概率为每个类。
classes_：真实类别
feature_count_：拟合过程中每个(类、特征)遇到的样本数量。该值由提供的样本重量加权。
n_features_：样本的特征数量
函数
fit(X, y[, sample_weight])
训练高斯贝叶斯算法
predict(X)
根据x预测样本类别
predict_log_proba(X)
返回测试向量X的对数概率估计值
predict_proba(X)
测试向量X的返回概率估计测试向量X的返回概率估计
score(X, y[, sample_weight])
返回数据得分，准确率
5.2.2常用API操作演示
代码演示
import pandas as pd
df = pd.DataFrame([[0,1],[1,1],[2,1],[3,-1],[4,-1],
[5,-1],[6,1],[7,1],[8,1],[9,-1]])
X = df[[0]]
Y = df[1]
from sklearn.naive_bayes import MultinomialNB
model = MultinomialNB()
model.fit(X,Y)
print(Y.values.T)
model.predict(X)
显示结果：
[ 1 1 1 -1 -1 -1 1 1 1 -1]
5.3伯努利贝叶斯
5.3.1API讲解
调用方式
sklearn.naive_bayes.BernoulliNB(alpha=1.0, binarize=0.0, fit_prior=True, class_prior=None)
参数释义
alpha：拉普拉斯平滑系数
fit_prior：是否学习类先验概率。如果为假，则使用统一的先验。
class_prior：类的先验概率。如果指定，则不根据数据调整先验。
属性
class_count_：拟合过程中遇到的每个类的样本数。该值由提供的样本重量加权。
class_log_prior_：平滑的经验对数概率为每个类。
classes_：真实类别
feature_count_：拟合过程中每个(类、特征)遇到的样本数量。该值由提供的样本重量加权。
n_features_：样本的特征数量
函数
fit(X, y[, sample_weight])
训练高斯贝叶斯算法
predict(X)
根据x预测样本类别
predict_log_proba(X)
返回测试向量X的对数概率估计值
predict_proba(X)
测试向量X的返回概率估计测试向量X的返回概率估计
score(X, y[, sample_weight])
返回数据得分，准确率
5.3.2常用API操作演示
代码演示
import pandas as pd
df = pd.DataFrame([[0,1],[1,1],[2,1],[3,-1],[4,-1],
[5,-1],[6,1],[7,1],[8,1],[9,-1]])
X = df[[0]]
Y = df[1]
from sklearn.naive_bayes import BernoulliNB
model = BernoulliNB()
model.fit(X,Y)
print(Y.values.T)
model.predict(X)
结果显示：
[ 1 1 1 -1 -1 -1 1 1 1 -1]
06聚类算法
6.1K-means
6.1.1API讲解
调用方式
sklearn.cluster.KMeans(n_clusters=8, init='k-means++', n_init=10, max_iter=300,
tol=1e-4, precompute_distances='auto', verbose=0, random_state=None, copy_x=True, n_jobs=None, algorithm='auto')
参数释义
n_clusters：生成的聚类数，即产生的质心（centroids）数。默认值8
max_iter：最大迭代次数，默认值300
n_init：用不同的质心初始化值运行算法的次数，最终解是在inertia意义下选出的最优结果。默认值10
init：有三个可选值：’k-means++’， ‘random’，或者传递一个ndarray向量。
此参数指定初始化方法，默认值为 ‘k-means++’。
- ‘k-means++’ 用一种特殊的方法选定初始质心从而能加速迭代过程的收敛（即上文中的k-means++介绍）
- ‘random’ 随机从训练数据中选取初始质心。
- 如果传递的是一个ndarray，则应该形如 (n_clusters, n_features) 并给出初始质心。
precompute_distances：三个可选值，‘auto’，True 或者 False。
预计算距离，计算速度更快但占用更多内存。
- ‘auto’：如果 样本数乘以聚类数大于 12million 的话则不预计算距离。This corresponds to about 100MB overhead per job using double precision.
- True：总是预先计算距离。
- False：永远不预先计算距离。
tol：与inertia结合来确定收敛条件。默认值1e-4
n_jobs：指定计算所用的进程数。内部原理是同时进行n_init指定次数的计算。
- 若值为 -1，则用所有的CPU进行运算。若值为1，则不进行并行运算，这样的话方便调试。
- 若值小于-1，则用到的CPU数为(n_cpus + 1 + n_jobs)。因此如果 n_jobs值为-2，则用到的CPU数为总CPU数减1。
random_state：整形或 numpy.RandomState 类型，可选
用于初始化质心的生成器（generator）。如果值为一个整数，则确定一个seed。此参数默认值为numpy的随机数生成器。
copy_x：当我们precomputing distances时，将数据中心化会得到更准确的结果。如果把此参数值设为True，则原始数据不会被改变。如果是False，则会直接在原始数据，默认值True
属性
cluster_centers_：聚类中心坐标
Labels_: 每个点的分类
inertia_：每个点到其簇的质心的距离之和。SSE
函数
fit(X[,y]):
计算k-means聚类。
fit_predict(X[,y]):
计算簇质心并给每个样本预测类别。
fit_transform(X[,y])：
计算簇并 transform X to cluster-distance space。
6.1.2常用API操作演示
代码演示
import numpy as np
from sklearn.cluster import KMeans
from sklearn.metrics import v_measure_score, silhouette_score
# 前两列数据为真实值，最后一列为标签
X = np.array([[1, 2], [2, 2], [6, 8], [7, 8]])
C = np.array([[1, 1], [2, 1]])
# 生成2个聚类
model = KMeans(n_clusters=2)
# 计算聚类
model.fit(X, C)
# 质心位置
print('聚类中心为：\n',model.cluster_centers_)
labels = model.labels_# 聚类预测结果
print('聚类结果：', labels)
print('最小平方误差(SSE)：', model.inertia_)#最小化平方误差E SSE
显示结果：
聚类中心为：
[[6.5 8. ]
[1.5 2. ]]
聚类结果： [1 1 0 0]
最小平方误差(SSE)： 1.0
6.2DBSCAN
6.2.1API详解
调用方式
sklearn.cluster.DBSCAN(eps=0.5, min_samples=5, metric=’euclidean’, metric_params=None, algorithm=’auto’, leaf_size=30, p=None, n_jobs=1)
参数释义
eps：设置选取半径，默认值0.5
min_samples：半径中样本最小值（生成簇的条件），默认值5
metric：距离度量方式，默认是欧式距离，也可以是曼哈顿距离或者切比雪夫距离
metric_params：计算距离的方式可能还有其他的参数需求，欧氏距离没有那就是none
algorithm：{‘auto’, ‘ball_tree’, ‘kd_tree’, ‘brute’}在DBSCAN中我们要找一个点他的近邻，这有三种算法，而auto会自动挑一个最好的给你，稀疏数据的话，一般就brute了
leaf_size：这和树有关，主要影响的是内存使用查询时间等
n_jobs：指定计算所用的进程数。内部原理是同时进行n_init指定次数的计算。默认值为1
属性
core_sample_indices_：半径范围内样本数
components_ :通过培训找到的每个核心样本的副本
labels_：给fit()的数据集中每个点的集群标签。
噪声样本被标记为-1
函数
fit_predict(X)
计算并预测样本
6.2.2常用API操作演示
代码演示
import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
# 画个圈圈
X1, y1=datasets.make_circles(n_samples=5000, factor=.6,
noise=.05)
#造一个聚类模型
X2, y2 = datasets.make_blobs(n_samples=1000, n_features=2, centers=[[1.2,1.2]], cluster_std=[[.1]],
random_state=9)
X = np.concatenate((X1, X2))
plt.scatter(X[:, 0], X[:, 1], marker='o')
plt.show()
from sklearn.cluster import DBSCAN
y_pred = DBSCAN().fit_predict(X)# 0.5, 5
plt.scatter(X[:, 0], X[:, 1], c=y_pred)
plt.show()
y_pred = DBSCAN(eps = 0.08, min_samples=3).fit_predict(X)
plt.scatter(X[:, 0], X[:, 1], c=y_pred)
plt.show()
显示结果：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HA4I4uG2-1589286817516)(E:\py-code\test1\大纲相关代码\1.jpg)][外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eFcA7VPT-1589286817521)(E:\py-code\test1\大纲相关代码\2.jpg)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C9VDil6b-1589286817528)(E:\py-code\test1\大纲相关代码\3.jpg)]
6.3层次聚类（凝聚）
6.3.1API讲解
调用方式
sklearn.cluster.AgglomerativeClustering(affinity=’euclidean’,compute_full_tree=’auto’, connectivity=None, linkage=’ward’,memory=Memory(cachedir=None),n_clusters=6,)
参数释义
affinity：距离度量方式，默认为欧式距离
connectivity:是否有连通性约束
linkage:距离度量方式
- average：计算两个簇的平均值
- complete：计算两个簇中最远样本点的距离
- single：计算两个初中最近样本点的距离
distance_threshold：设置距离阈值
属性
n_clusters_：计算的簇数
labels_：每个样本点划分到哪一个簇
n_leaves_：层次树中的叶节点数
n_connected_components_：图中连接组件的估计数目
children_：每个非叶节点的子节点。
函数
fit(X, y=None)
计算层次聚类的数据
6.3.2常用API操作演示
代码演示
import pandas as pd
from sklearn.cluster import AgglomerativeClustering
import matplotlib.pyplot as plt
import scipy.cluster.hierarchy as sch #专门处理层次聚类图像
dict = {'x1':[16.9,38.5,39.5,80.8,82,34.6,116.1]} # 加载数据点
data = pd.DataFrame(dict)
print(data)
ac = AgglomerativeClustering(n_clusters=3) #凝聚聚类, 生成三个簇
ac.fit(data)
data['cluster'] = ac.labels_ #将聚类结果进行处理，分别对应样本
print(data)
# 生成可视化效果
# 生成点与点之间的距离矩阵,这里用的欧氏距离:
dis = sch.distance.pdist(data, 'euclidean')
# 将层级聚类结果以树状图表示出来
model = sch.linkage(dis, method='average')
pic = sch.dendrogram(model,labels=['A','B','C','D','E','F','G'])
plt.show()
显示结果：
x1
0 16.9
1 38.5
2 39.5
3 80.8
4 82.0
5 34.6
6 116.1
x1 cluster
0 16.9 0
1 38.5 0
2 39.5 0
3 80.8 1
4 82.0 1
5 34.6 0
6 116.1 2
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ieqcfg74-1589286817534)(E:\py-code\test1\MachineLearning\chapter16\3.jpg)]
6.4GMM高斯混合模型
6.4.1API讲解
调用方式
sklearn.mixture.GaussianMixture(n_components=1, covariance_type=’full’, tol=0.001, reg_covar=1e-06, max_iter=100, n_init=1, init_params=’kmeans’, weights_init=None, means_init=None, precisions_init=None, random_state=None, warm_start=False, verbose=0, verbose_interval=10)
参数释义
n_components ：混合元素（聚类）的数量，默认为1
*covariance_type：*描述要使用的协方差参数类型的字符串，必选一个(‘full’ , ‘tied’, ‘diag’, ‘spherical’)，默认为full。
full:每个混合元素有它公用的协方差矩阵；tied:每个混合元素共享同一个公共的协方差矩阵；
diag:每个混合元素有它自己的对角矩阵；spherical:每个混合元素都有自己单独的方差值
*tol：*float类型, 默认值： 0.001.收敛阈值，当平均增益低于这个值时迭代停止。
*reg_covar：*float类型, 协方差对角线上的非负正则化参数，默认值： 1e-6 接近于0.
max_iter：最大迭代次数，默认为100
n_init：执行初始化操作数量，保持最好的结果，默认为1
init_params :可选 {‘kmeans’, ‘random’}, 默认值为 ‘kmeans’.初始化权重、均值及精度的方法，作用：用随机方法还是用kmeans方法初始化
weights_init：初始化权重列表，如果没有给定，那么使用init_params参数给定的方法来进行创建，默认为None
means_init：初始化均值列表，如果没有给定，那么使用init_params参数给定的方法来进行创建，默认为None
precisions_init: 初始化精度列表，如果没有给定，那么使用init_params参数给定的方法来进行创建，默认为None，它的形状依靠协方差类型
- ‘spherical’ (n_components,)
- ‘tied’(n_features, n_features)
- ‘diag’(n_components, n_features)
- ‘full’(n_components, n_features, n_features)
random_state : 类型int, 随机数种子,默认为None.
warn_stat：布尔类型，默认为False，当该值为true的时候，最后一次的学习结果作为下一次调用的初始化参数，在类似问题被多次训练的时候，可以加快收敛速度。在这种情况下‘n_init’可以忽略，并且在第一次调用时只发生一个初始化。
verbose : int类型, 默认为0.作用：可以冗余输出，如果为1，它会打印正确的初始化结果和每一次迭代步骤。如果大于1，则打印日志概率和每一步所需的时间。
verbose_interval : int类型, 默认为 10.作用：下一次打印之前的迭代发生次数
属性
weights_ :每个混合元素权重
means_ : 每个混合元素均值
covariances_ : 每个混合元素的协方差，它的形状依靠协方差类型
- ‘spherical’ (n_components,)
- ‘tied’(n_features, n_features)
- ‘diag’(n_components, n_features)
- ‘full’(n_components, n_features, n_features)
precisions_ : array-like，每个混合元素精度矩阵，精度矩阵是协方差矩阵的逆。协方差矩阵是对称正定的，因此高斯混合可以用精度矩阵等价地参数化。存储精度矩阵而不是协方差矩阵使得在测试时间计算新样本的对数似然更有效。它的形状依靠协方差类型，
- ‘spherical’ (n_components,)
- ‘tied’(n_features, n_features)
- ‘diag’(n_components, n_features)
- ‘full’(n_components, n_features, n_features)
converged_ : bool类型，在fit()中达到收敛时为true，否则为false。
lower_bound_ : float类型，EM最佳拟合的对数似然(与模型相关的训练数据)的下限值。
函数
fit(self, X[, y])
用EM算法估计模型参数。
fit_predict(self, X[, y])
用X估计模型参数，并预测X的标签。
predict(self, X)
使用训练模型预测X中数据样本的标签。
predict_proba(self, X)
在给定数据的情况下，预测每个分量的后验概率。
6.4.2常用API操作演示
代码演示
import pandas as pd
from sklearn.mixture import GaussianMixture
from sklearn.metrics import accuracy_score
## 数据加载
data = pd.read_csv('../datas/HeightWeight.csv')
data_x = data[data.columns[1:]]
data_y = data[data.columns[0]]
data.head()
## 模型创建及训练
gmm = GaussianMixture(n_components=2, covariance_type='diag', random_state=28)
gmm.fit(data_x)
## 模型相关参数输出
print ('均值 = \n', gmm.means_)
print ('方差 = \n', gmm.covariances_)
显示结果：
均值 =
[[160.18762308 54.60507549]
[172.019813 66.08302048]]
方差 =
[[18.47965125 28.75959999]
[30.35821219 70.62937897]]
[0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 1 0 0 0 0 0 1 0 0 1 0 0 1 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 0 0 0 1 0 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1 1 1 1 0 1 0 1 0 0 1 1 1 0 0 1
1 1 1]
[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 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 1 1 1 1
1 1 1]
0.8245614035087719
_features)
- ‘diag’(n_components, n_features)
- ‘full’(n_components, n_features, n_features)
random_state : 类型int, 随机数种子,默认为None.
warn_stat：布尔类型，默认为False，当该值为true的时候，最后一次的学习结果作为下一次调用的初始化参数，在类似问题被多次训练的时候，可以加快收敛速度。在这种情况下‘n_init’可以忽略，并且在第一次调用时只发生一个初始化。
verbose : int类型, 默认为0.作用：可以冗余输出，如果为1，它会打印正确的初始化结果和每一次迭代步骤。如果大于1，则打印日志概率和每一步所需的时间。
verbose_interval : int类型, 默认为 10.作用：下一次打印之前的迭代发生次数
属性
weights_ :每个混合元素权重
means_ : 每个混合元素均值
covariances_ : 每个混合元素的协方差，它的形状依靠协方差类型
- ‘spherical’ (n_components,)
- ‘tied’(n_features, n_features)
- ‘diag’(n_components, n_features)
- ‘full’(n_components, n_features, n_features)
precisions_ : array-like，每个混合元素精度矩阵，精度矩阵是协方差矩阵的逆。协方差矩阵是对称正定的，因此高斯混合可以用精度矩阵等价地参数化。存储精度矩阵而不是协方差矩阵使得在测试时间计算新样本的对数似然更有效。它的形状依靠协方差类型，
- ‘spherical’ (n_components,)
- ‘tied’(n_features, n_features)
- ‘diag’(n_components, n_features)
- ‘full’(n_components, n_features, n_features)
converged_ : bool类型，在fit()中达到收敛时为true，否则为false。
lower_bound_ : float类型，EM最佳拟合的对数似然(与模型相关的训练数据)的下限值。
函数
fit(self, X[, y])
用EM算法估计模型参数。
fit_predict(self, X[, y])
用X估计模型参数，并预测X的标签。
predict(self, X)
使用训练模型预测X中数据样本的标签。
predict_proba(self, X)
在给定数据的情况下，预测每个分量的后验概率。
6.4.2常用API操作演示
代码演示
import pandas as pd
from sklearn.mixture import GaussianMixture
from sklearn.metrics import accuracy_score
## 数据加载
data = pd.read_csv('../datas/HeightWeight.csv')
data_x = data[data.columns[1:]]
data_y = data[data.columns[0]]
data.head()
## 模型创建及训练
gmm = GaussianMixture(n_components=2, covariance_type='diag', random_state=28)
gmm.fit(data_x)
## 模型相关参数输出
print ('均值 = \n', gmm.means_)
print ('方差 = \n', gmm.covariances_)
显示结果：
均值 =
[[160.18762308 54.60507549]
[172.019813 66.08302048]]
方差 =
[[18.47965125 28.75959999]
[30.35821219 70.62937897]]
[0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 1 0 0 0 0 0 1 0 0 1 0 0 1 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 0 0 0 1 0 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1 1 1 1 0 1 0 1 0 0 1 1 1 0 0 1
1 1 1]
[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 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 1 1 1 1
1 1 1]
0.8245614035087719
6427
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
