Python机器学习（十）经典算法汇编

np.empty(len(theta))for i in range(len(theta)):theta_1 = theta.copytheta_1[i] += epsilontheta_2 = theta.copytheta_2[i] -= epsilonres[i] = (J(theta_1, X_b, y) - J(theta_2, X_b, y)) / (2 * epsilon)return res# 很低成本局部急剧下降，探寻给定的thetadef gradient_descent(dJ, X_b, y, initial_theta, eta, n_iters=1e4, epsilon=1e-8):theta = initial_thetai_iter = 0while i_iter < n_iters:gradient = dJ(theta, X_b, y)last_theta = thetatheta = theta - eta * gradientif(abs(J(theta, X_b, y) - J(last_theta, X_b, y)) < epsilon):breaki_iter += 1return theta# 变数入口常量第一个，要选定dJ变数是什么样的X_b = np.hstack([np.ones((len(X), 1)), X])initial_theta = np.zeros(X_b.shape[1])eta = 0.01# 用做debug方基本型为theta = gradient_descent(dJ_debug, X_b, y, initial_theta, eta)# 用做数论不等基本型方基本型为theta = gradient_descent(dJ_math, X_b, y, initial_theta, eta)# 得都是的这两个theta一定但会是相同的

由于是求方差第二大，因此用做的是局部上升律

PCA解律可不在前处理事件展掀开归一转化处理事件，否则将但会找至少；大成份

# 对于二维的数据资料结果显示来说from sklearn.decomposition import PCApca = PCA(n_components=1) #选定必需移去的前n个；大成份，不选定为配置文件移去所有pca.fit(X)

比如，要用做KNN定义解律，到时展掀开数据资料的降维操作者

from sklearn.decomposition import PCApca = PCA(n_components=2) #这里也可以给一个百分比，都是就让移去的数据资料的方差占到比pca.fit(X_train)#培训集和的测试集必需展掀开相同降维处理事件操作者X_train_reduction = pca.transform(X_train)X_test_reduction = pca.transform(X_test)#降维启动后就可以送来建模展掀开意味着knn_clf = KNeighborsClassifierknn_clf.fit(X_train_reduction, y_train)knn_clf.score(X_test_reduction, y_test)

选定的维数，能说明了原数据资料的方差的百分比

pca.explained_variance_ratio_# 选定移去所有的；大成份pca = PCA(n_components=X_train.shape[1])pca.fit(X_train)pca.explained_variance_ratio_# 查询降维后特性的维数pca.n_components_

把数据资料降维到2维，可以展掀开scatter的可视转化操作者

到时用做pca降维，便便种系统，升维

from sklearn.decomposition import PCApca = PCA(0.7)pca.fit(X)pca.n_components_X_reduction = pca.transform(X)X_inversed = pca.inverse_transform(X_reduction)

整数回去顾必需选定高达的n-， degree

意味着的将以后是一条夹角

只有一个特性的结果显示，展掀开整数重归可以意味着都是斜率，并且在二维平面图上展掀开画 而对于不具多个特性的结果显示，比方说可以展掀开整数重归，但是可不可视转化意味着都是来的斜率 from sklearn.preprocessing import PolynomialFeaturesfrom sklearn.linear_model import LinearRegressionfrom sklearn.preprocessing import StandardScalerfrom sklearn.pipeline import Pipelinepoly_reg = Pipeline([("poly", PolynomialFeatures(degree=2)),("std_scaler", StandardScaler),("lin_reg", LinearRegression)])poly_reg.fit(X, y)y_predict = poly_reg.predict(X)# 对二维数据资料点可以画意味着后的缩滚plt.scatter(X, y)plt.plot(np.sort(x), y_predict[np.argsort(x)], color=‘r‘)plt.show#更为常用的是，把pipeline写到在变数中的def PolynomialRegression(degree):return Pipeline([("poly", PolynomialFeatures(degree=degree)),("std_scaler", StandardScaler),("lin_reg", LinearRegression)])poly2_reg = PolynomialRegression(degree=2)poly2_reg.fit(X, y)y2_predict = poly2_reg.predict(X)mean_squared_error(y, y2_predict)

恰当：

GridSearchCV：用做探寻给定建模的给定的常量 Pipeline：用做将几个流程整合在朋友们（PolynomialFeatures、StandardScaler、LinearRegression）

如果非要把上两者写到在朋友们，一定但会把选定好param_grid常量的grid_search作为成员，传播给Pipeline

首到时恰当：

建模泛转化是为了解决问题建模过意味着的疑虑 岩重归是建模特例转化的一种处理事件方基本型为，也统称L2特例转化 岩重归是时域重归的一种特例转化处理事件后的建模（作为pipeline的成员用做） from sklearn.linear_model import Ridgefrom sklearn.preprocessing import PolynomialFeaturesfrom sklearn.preprocessing import StandardScalerfrom sklearn.pipeline import Pipelinedef RidgeRegression(degree, alpha):return Pipeline([("poly", PolynomialFeatures(degree=degree)),("std_scaler", StandardScaler),("ridge_reg", Ridge(alpha=alpha))])ridge_reg = RidgeRegression(degree=20, alpha=0.0001)ridge_reg.fit(X_train, y_train)y_predict = ridge_reg.predict(X_test)mean_squared_error(y_test, y_predict)

示例中的：

alpha为L2特例项在后的系数，都是的意义与LASSO重归相同

alpha越少小，越少偏向于选项复杂建模 alpha越少大，越少偏向于选项直观建模

Ridge重归、LASSO重归的相异

岩重归是建模特例转化的一种处理事件方基本型为，也统称L1特例转化 岩重归是时域重归的一种特例转化处理事件后的建模（作为pipeline的成员用做） from sklearn.linear_model import Lassofrom sklearn.preprocessing import PolynomialFeaturesfrom sklearn.preprocessing import StandardScalerfrom sklearn.pipeline import Pipelinedef LassoRegression(degree, alpha):return Pipeline([("poly", PolynomialFeatures(degree=degree)),("std_scaler", StandardScaler),("lasso_reg", Lasso(alpha=alpha))])lasso_reg = LassoRegression(3, 0.01)lasso_reg.fit(X_train, y_train)y_predict = lasso_reg.predict(X_test)mean_squared_error(y_test, y_predict)

将结果显示特性与结果显示引发的概亲率保持联系朋友们。

既可看做重归解律，也可定义解律 往往作为二定义解律 # 不规则决策者边境线画工具def plot_decision_boundary(model, axis):x0, x1 = np.meshgrid(np.linspace(axis[0], axis[1], int((axis[1] - axis[0]) * 100)).reshape(-1, 1),np.linspace(axis[2], axis[3], int((axis[3] - axis[2]) * 100)).reshape(-1, 1))X_new = np.c_[x0.ravel, x1.ravel]y_predict = model.predict(X_new)zz = y_predict.reshape(x0.shape)from matplotlib.colors import ListedColormapcustom_cmap = ListedColormap([‘#EF9A9A‘, ‘#FFF59D‘, ‘#90CAF9‘])plt.contourf(x0, x1, zz, linewidth=5, cmap=custom_cmap)#此处为时域逻辑学重归from sklearn.linear_model import LogisticRegressionlog_reg = LogisticRegressionlog_reg.fit(X_train, y_train)log_reg.score(X_test, y_test)画决策者边境线plot_decision_boundary(log_reg, axis=[4, 7.5, 1.5, 4.5])plt.scatter(X[y==0, 0], X[y==0, 1], color=‘r‘)plt.scatter(X[y==1, 0], X[y==1, 1], color=‘blue‘)plt.show

比方说，相近于整数重归，必需用做Pipeline结构整数特性项

from sklearn.pipeline import Pipelinefrom sklearn.preprocessing import PolynomialFeaturesfrom sklearn.preprocessing import StandardScalerfrom sklearn.linear_model import LogisticRegressiondef PolynomialLogisticRegression(degree):return Pipeline([(‘poly‘,PolynomialFeatures(degree=degree)),(‘std_scaler‘,StandardScaler),(‘log_reg‘,LogisticRegression)])poly_log_reg = PolynomialLogisticRegression(degree=2)poly_log_reg.fit(X, y)poly_log_reg.score(X, y)

如果有必需，可以画都是决策者边境线

plot_decision_boundary(poly_log_reg, axis=[-4, 4, -4, 4])plt.scatter(X[y==0, 0], X[y==0, 1])plt.scatter(X[y==1, 0], X[y==1, 1])plt.show

不等基本型为：

C * J(θ) + L1

C * J(θ) + L2

上基本型中的：

C越少大，L1、L2的起着越少弱，建模越少偏向复杂 C越少小，相比较L1、L2起着越少强， J(θ) 起着越少弱，建模越少偏向直观 def PolynomialLogisticRegression(degree, C, penalty=‘l2‘):return Pipeline([(‘poly‘,PolynomialFeatures(degree=degree)),(‘std_scaler‘,StandardScaler),(‘log_reg‘,LogisticRegression(C = C, penalty=penalty))# 逻辑学重归建模，配置文件为 penalty=‘l2‘])

将只仅限于做二定义的解律，改建为仅限于做多定义疑虑

scikit元件了OvO OvR这两个类，方便其他二定义解律，用做这两个类借助于多定义

例弟中的：log_reg是仍未建立好的逻辑学重归二定义器

from sklearn.multiclass import OneVsRestClassifierovr = OneVsRestClassifier(log_reg)ovr.fit(X_train, y_train)ovr.score(X_test, y_test)from sklearn.multiclass import OneVsOneClassifierovo = OneVsOneClassifier(log_reg)ovo.fit(X_train, y_train)ovo.score(X_test, y_test)

忽略

由于涉及到最南端的某种程度，因此，在SVM意味着之前，不必到时展掀开数据资料标准转化

支撑向量机要意味着的优转化目的是：

使 “给定决策者边境线” 到与两个一般来说的在在的结果显示 的最南端最南端

即，使得 margin 第二大转化

界定：

Hard Margin SVM Soft Margin SVM

为了强化SVM建模的泛转化能力，必需展掀开特例转化处理事件，比方说有L1、L2特例转化

特例转化即弱转化附送条件，使得某些结果显示可以以后Margin区域内

刑罚系数 C 是乘在特例项在后的

min12||w||2+C∑i=1mξi,L1特例项min12||w||2+C∑i=1mξi,L1特例项

min12||w||2+C∑i=1mξ2i,L2特例项min12||w||2+C∑i=1mξi2,L2特例项

变转化规律 ：

C越少大，容错自由空间越少小，越少偏向于Hard Margin C越少小，容错自由空间越少大，越少偏向于Soft Margin from sklearn.preprocessing import StandardScalerstandardScaler = StandardScalerstandardScaler.fit(X)X_standard = standardScaler.transform(X)from sklearn.svm import LinearSVCsvc = LinearSVC(C=1e9)svc.fit(X_standard, y)

简洁起见，可以用Pipeline外包装朋友们

from sklearn.preprocessing import StandardScalerfrom sklearn.svm import LinearSVCfrom sklearn.pipeline import Pipelinedef Linear_svc(C=1.0):return Pipeline([("std_scaler", StandardScaler),("linearSVC", LinearSVC(C=C))])linear_svc = Linear_svc(C=1e5)linear_svc.fit(X, y)

恰当：用做整数氢变数的目的都是将数据资料升维，使得原来时域不可分的数据资料变得时域可分

在SVM中的用做整数特性有两种方基本型为

用做时域SVM，通过pipeline将 **poly 、std 、 linear_svc ** 三个连接朋友们 用做整数氢变数SVM, 则Pipeline可用外包装 std 、 kernelSVC 两个类 # 现代上用做整数特性的SVMfrom sklearn.preprocessing import PolynomialFeatures, StandardScalerfrom sklearn.svm import LinearSVCfrom sklearn.pipeline import Pipelinedef PolynomialSVC(degree, C=1.0):return Pipeline([("ploy", PolynomialFeatures(degree=degree)),("std_standard", StandardScaler),("linearSVC", LinearSVC(C=C))])poly_svc = PolynomialSVC(degree=3)poly_svc.fit(X, y) # 用做整数氢变数的SVMfrom sklearn.svm import SVCdef PolynomialKernelSVC(degree, C=1.0):return Pipeline([("std_standard", StandardScaler),("kernelSVC", SVC(kernel=‘poly‘, degree=degree, C=C))])poly_kernel_svc = PolynomialKernelSVC(degree=3)poly_kernel_svc.fit(X, y)

将原来是m∗nm∗n的数据资料变为m∗mm∗m

from sklearn.preprocessing import StandardScalerfrom sklearn.svm import SVCfrom sklearn.pipeline import Pipelinedef RBFkernelSVC(gamma=1.0):return Pipeline([("std_standard", StandardScaler),("svc", SVC(kernel="rbf", gamma=gamma))])svc = RBFkernelSVC(gamma=1.0)svc.fit(X, y)

极限常量gamma γγ 规律：

gamma越少大，拉普拉斯氢越少“窄”，颈部越少“尖” gamma越少小，拉普拉斯氢越少“周长”，颈部越少“宽广”，可视化叉越远少掀开

若gamma很大，但会造成 过意味着

通用可以界定时域SVR和整数SVR

from sklearn.preprocessing import StandardScalerfrom sklearn.svm import LinearSVRfrom sklearn.svm import SVRfrom sklearn.pipeline import Pipelinedef StandardLinearSVR(epsilon=0.1):return Pipeline([("std_scaler", StandardScaler),("linearSVR", LinearSVR(epsilon=epsilon))])svr = StandardLinearSVRsvr.fit(X_train, y_train)svr.score(X_test, y_test)# 可以用做cross_val_score来获交叉实验者的佳绩，佳绩非常准确

ID3、C4.5都是用做“entropy"评判方基本型为

CART(Classification and Regression Tree)用做的是“gini"评判方基本型为

常用极限常量：

max_depth min_samples_split （所设很小的之外继续界定的结果显示存量 ） min_samples_leaf （选定叶弟给定很小的系数得忽略结果显示的存量 ） max_leaf_nodes （选定，最多能生长都是来的叶弟给定的存量 ） from sklearn.tree import DecisionTreeClassifierdt_clf = DecisionTreeClassifier(max_depth=2, criterion="gini")# dt_clf = DecisionTreeClassifier(max_depth=2, criterion="entropy")dt_clf.fit(X, y) from sklearn.tree import DecisionTreeRegressordt_reg = DecisionTreeRegressordt_reg.fit(X_train, y_train)dt_reg.score(X_test, y_test)# 计计的是R2系数

把几种定义建模外包装在朋友们，根据每种建模的投票结果来得都是终于得都是结论一般来说

可以到时用做网格搜索把每种建模的常量调至给定，便来Voting

from sklearn.ensemble import VotingClassifierfrom sklearn.linear_model import LogisticRegressionfrom sklearn.svm import SVCfrom sklearn.tree import DecisionTreeClassifiervoting_clf = VotingClassifier(estimators=[("log_clf",LogisticRegression),("svm_clf", SVC),("dt_clf", DecisionTreeClassifier)], voting=‘hard‘)voting_clf.fit(X_train, y_train)voting_clf.score(X_test, y_test)

更为理论上的投票一定但会考虑每种建模的系数，即考虑每种建模对自己定义结果的 有把握某种程度

所以，每种建模都一定但会能少于结果的概亲率

逻辑学重归 KNN 根本原因（叶弟给定一般都是成份一类数据资料，因此可以有概亲率） SVM中的的SVC（可选定probability常量为True） soft_voting_clf = VotingClassifier(estimators=[("log_clf",LogisticRegression),("svm_clf", SVC(probability=True)),("dt_clf", DecisionTreeClassifier(random_state=666))], voting=‘soft‘)soft_voting_clf.fit(X_train, y_train)soft_voting_clf.score(X_test, y_test)

（1）Bagging(滚回去时域) 和 Pasting(不滚回去时域)，由常量 bootstrap 来选定

True：滚回去时域 False：不滚回去时域

（2）这类应用于软件深造工具必需选定一个 base estimator

（3）滚回去时域，但会存在 oob (out of bag) 的结果显示数据资料，百分比左右37%，正好作为的测试集

obb_score=True/False , 确实用做oob作为的测试集

（4）转化成差异转化的方基本型为：

只针对特性展掀开随机均系数：random subspace 既针对结果显示，又针对特性随机均系数： random patches random_subspaces_clf = BaggingClassifier(DecisionTreeClassifier,n_estimators=500, max_samples=500,bootstrap=True, oob_score=True,n_jobs=-1,max_features=1, bootstrap_features=True)random_subspaces_clf.fit(X, y)random_subspaces_clf.oob_score_random_patches_clf = BaggingClassifier(DecisionTreeClassifier,n_estimators=500, max_samples=100,bootstrap=True, oob_score=True,n_jobs=-1,max_features=1, bootstrap_features=True)random_patches_clf.fit(X, y)random_patches_clf.oob_score_

常量说明了：

max_samples: 如果和结果显示总数一致，则不展掀开结果显示随机均系数

max_features: 选定随机均系数特性的取值（应小于结果显示维数）

bootstrap_features: 选定确实展掀开随机特性均系数

oob_score: 选定是都用oob结果显示来评分

bootstrap: 选定确实展掀开滚回去时域

随机树林是选定了 Base Estimator为Decision Tree 的Bagging应用于软件深造建模

仍未被scikit元件好，可以直接用做

from sklearn.ensemble import RandomForestClassifierrf_clf = RandomForestClassifier(n_estimators=500, random_state=666, oob_score=True, n_jobs=-1)rf_clf.fit(X, y)rf_clf.oob_score_#因为随机树林是基于根本原因的，因此，根本原因的相关常量这里都可以选定修改rf_clf2 = RandomForestClassifier(n_estimators=500, random_state=666, max_leaf_nodes=16, oob_score=True, n_jobs=-1)rf_clf2.fit(X, y)rf_clf.oob_score_

Base Estimator为Decision Tree 的Bagging应用于软件深造建模

特征：

根本原因在给定界定上，用做随机的特性和电位

透过了额外的随机性，可以抑制过意味着，但但会增大Bias (偏离)

不具加速的培训速度

from sklearn.ensemble import ExtraTreesRegressoret_clf = ExtraTreesClassifier(n_estimators=500, bootstrap=True, oob_score=True, random_state=666)et_clf.fit(X, y)et_clf.oob_score_

每个弟建模建模都在试着增强（boost）整体而言的视觉效果，通过不断的建模迭代，改版结果显示点的系数

Ada Boosting不会oob的结果显示，因此必需展掀开 train_test_split

必需选定 Base Estimator

from sklearn.ensemble import AdaBoostClassifierfrom sklearn.tree import DecisionTreeClassifierada_clf = AdaBoostClassifier(DecisionTreeClassifier(max_depth=2), n_estimators=500)ada_clf.fit(X_train, y_train)ada_clf.score(X_test, y_test)

培训一个建模m1， 转化成偏差e1

针对e1培训第二个建模m2， 转化成偏差e2

针对e2培训第二个建模m3， 转化成偏差e3

......

终于的得都是结论建模是：m1+m2+m3+...m1+m2+m3+...

Gradient Boosting是基于根本原因的，可不选定Base Estimator

from sklearn.ensemble import GradientBoostingClassifiergb_clf = GradientBoostingClassifier(max_depth=2, n_estimators=30)gb_clf.fit(X_train, y_train)gb_clf.score(X_test, y_test)总结

上述说明的应用于软件深造建模，不仅可以用做解决问题定义疑虑，也可解决问题重归疑虑

from sklearn.ensemble import BaggingRegressorfrom sklearn.ensemble import RandomForestRegressorfrom sklearn.ensemble import ExtraTreesRegressorfrom sklearn.ensemble import AdaBoostRegressorfrom sklearn.ensemble import GradientBoostingRegressor import numpy as npimport matplotlib.pyplot as pltfrom sklearn.tree import DecisionTreeRegressorfrom sklearn.ensemble import AdaBoostRegressor# 结构的测试变数rng = np.random.RandomState(1)X = np.linspace(-5, 5, 200)[:, np.newaxis]y = np.sin(X).ravel + np.sin(6 * X).ravel + rng.normal(0, 0.1, X.shape[0])# 重归根本原因dt_reg = DecisionTreeRegressor(max_depth=4)# 应用于软件建模下的重归根本原因ada_dt_reg = AdaBoostRegressor(DecisionTreeRegressor(max_depth=4),n_estimators=200, random_state=rng)dt_reg.fit(X, y)ada_dt_reg.fit(X, y)# 得都是结论y_1 = dt_reg.predict(X)y_2 = ada_dt_reg.predict(X)# 绘成plt.figureplt.scatter(X, y, c="k", )plt.plot(X, y_1, c="g", , linewidth=2)plt.plot(X, y_2, c="r", , linewidth=2)plt.xlabel("data")plt.ylabel("target")plt.title("Boosted Decision Tree Regression")plt.legendplt.show

K-means解律借助于：文章介绍了k-means解律的基本原理和scikit中的元件的kmeans托的基本常量的意义

K-means掀开发人员阐释 ： 这篇文章阐释了scikit中的kmeans的掀开发人员

举例来说的notebook笔记档案：git货仓

最简单示例：

from matplotlib import pyplot as pltfrom sklearn.metrics import accuracy_scoreimport numpy as npimport seaborn as sns; sns.set%matplotlib inline

结构数据资料集

from sklearn.datasets.samples_generator import make_blobsX, y_true = make_blobs(n_samples=300, centers=4, cluster_std=0.60, random_state=0)plt.scatter(X[:,0], X[:, 1], s=50) from sklearn.cluster import KMeanskmeans = KMeans(n_clusters=4)kmeans.fit(X)y_kmeans = kmeans.predict(X)

画聚类结果， 画都是聚类为中的心

plt.scatter(X[:, 0], X[:, 1], c=y_kmeans, s=50, cmap=‘viridis‘)centers = kmeans.cluster_centers_plt.scatter(centers[:,0], centers[:, 1], c=‘black‘, s=80, marker=‘x‘)

对于非时域边境线的kmeans聚类的介绍，查询于《python数据资料科学手册》P410

结构数据资料

from sklearn.datasets import make_moonsX, y = make_moons(200, noise=0.05, random_state=0)

现代kmeans聚类失利的原因

labels = KMeans(n_clusters=2, random_state=0).fit_predict(X)plt.scatter(X[:, 0], X[:, 1], c=labels, s=50, cmap=‘viridis‘)

应用于氢工具， 将数据资料对角到更为高纬的自由空间，变成时域可分

from sklearn.cluster import SpectralClusteringmodel = SpectralClustering(n_clusters=2, affinity=‘nearest_neighbors‘, assign_labels=‘kmeans‘)labels = model.fit_predict(X)plt.scatter(X[:, 0], X[:, 1], c=labels, s=50, cmap=‘viridis‘)

手写到数字识别例弟

from sklearn.datasets import load_digitsdigits = load_digits

展掀开聚类

kmeans = KMeans(n_clusters=10, random_state=0)clusters = kmeans.fit_predict(digits.data)kmeans.cluster_centers_.shape(10, 64)

可以将这些克族为中的心点看做是不具纪念性的数字

fig, ax = plt.subplots(2, 5, figsize=(8, 3))centers = kmeans.cluster_centers_.reshape(10, 8, 8)for axi, center in zip(ax.flat, centers):axi.set(xticks=, yticks=)axi.imshow(center, interpolation=‘nearest‘, cmap=plt.cm.binary)

展掀开阴性意味着

from scipy.stats import modelabels = np.zeros_like(clusters)for i in range(10):#赢取聚类结果第i类的 True Flase 类型的index时域mask = (clusters ==i)#根据index时域，找都是这些target中的的阴性，作为确实的labellabels[mask] = mode(digits.target[mask])[0]#有了确实的高效率，可以展掀开稳定性计计accuracy_score(digits.target, labels)0.7935447968836951 from sklearn.metrics import confusion_matrixmat = confusion_matrix(digits.target, labels)np.fill_diagonal(mat, 0)sns.heatmap(mat.T, square=True, annot=True, fmt=‘d‘, cbar=False,xticklabels=digits.target_names,yticklabels=digits.target_names)plt.xlabel(‘true label‘)plt.ylabel(‘predicted label‘)

紧接著高纬的 非时域的数据资料

通过射影深造

对角到很低维自由空间

from sklearn.manifold import TSNE# 对角数据资料# 此过程相比较不间断tsen = TSNE(n_components=2, init=‘pca‘, random_state=0)digits_proj = tsen.fit_transform(digits.data)#计计聚类的结果kmeans = KMeans(n_clusters=10, random_state=0)clusters = kmeans.fit_predict(digits_proj)#将聚类结果和确实附加展掀开意味着labels = np.zeros_like(clusters)for i in range(10):mask = (clusters == i)labels[mask] = mode(digits.target[mask])[0]# 计计稳定性accuracy_score(digits.target, labels)

k-means解律的非概亲率性和仅根据到克族为中的心的最南端授命克族的特性导致该解律性能指标很低下

且k-means解律只对直观的，分离性能指标好的，并且是球形原产的数据资料有相比较好的视觉效果

举例来说中的所有示例的借助于已上传至 git货仓

通过最简单来仔细观察K-means解律的缺陷

%matplotlib inlineimport matplotlib.pyplot as pltimport seaborn as sns; sns.setimport numpy as np# 聚合数据资料点from sklearn.datasets.samples_generator import make_blobsX, y_true = make_blobs(n_samples=400, centers=4,cluster_std=0.60, random_state=0)X = X[:, ::-1] # flip axes for better plotting# 画都是kmeans聚类后的附加的结果from sklearn.cluster import KMeanskmeans = KMeans(4, random_state=0)labels = kmeans.fit(X).predict(X)plt.scatter(X[:, 0], X[:, 1], c=labels, s=40, cmap=‘viridis‘);centers = kmeans.cluster_centers_plt.scatter(centers[:,0], centers[:, 1], c=‘black‘, s=80, marker=‘x‘)

k-means解律略很低于在每个克族的为中的心滚置了一个菱形，（针对此处的二维数据资料来说）

倾角是根据最南端的点与克族为中的心点的最南端计都是

上面用一个变数将这个聚类菱形可视转化

from sklearn.cluster import KMeansfrom scipy.spatial.distance import cdistdef plot_kmeans(kmeans, X, n_clusters=4, rseed=0, ax=None):labels = kmeans.fit_predict(X)# plot the input dataax = ax or plt.gcaax.axis(‘equal‘)ax.scatter(X[:, 0], X[:, 1], c=labels, s=40, cmap=‘viridis‘, zorder=2)# plot the representation of the KMeans modelcenters = kmeans.cluster_centers_ax.scatter(centers[:,0], centers[:, 1], c=‘black‘, s=150, marker=‘x‘)radii = [cdist(X[labels == i], [center]).max for i, center in enumerate(centers)]#用列出不等基本型基本型求都是每一个聚类为中的心 i = 0, 1, 2, 3在自己的所属克族的最南端的第二大系数#labels == i 送回去一个布尔型index，所以X[labels == i]只取都是i这个克族类的数据资料点#求都是这些数据资料点到聚类为中的心的最南端cdist(X[labels == i], [center]) 便求第二大系数 .maxfor c, r in zip(centers, radii):ax.add_patch(plt.Circle(c, r, fc=‘#CCCCCC‘, lw=3, alpha=0.5, zorder=1))#如果数据资料点不是球形原产的k-means解律的聚类视觉效果就但会受到影响rng = np.random.RandomState(13)# 这里乘以一个2,2的时域，略很低于在自由空间上继续执行螺旋剪切操作者X_stretched = np.dot(X, rng.randn(2, 2))kmeans = KMeans(n_clusters=4, random_state=0)plot_kmeans(kmeans, X_stretched)

拉普拉斯分离建模不必计计都是每取值据资料点，仅指每个克族为中的心的概亲率大小

在配置文件常量所设的、数据资料直观可分的原因下，

GMM的定义视觉效果与k-means基本一致

from sklearn.mixture import GaussianMixturegmm = GaussianMixture(n_components=4).fit(X)labels = gmm.predict(X)plt.scatter(X[:, 0], X[:, 1], c=labels, s=40, cmap=‘viridis‘);#gmm的为中的心点叫做 means_centers = gmm.means_plt.scatter(centers[:,0], centers[:, 1], c=‘black‘, s=80, marker=‘x‘);

赢取数据资料的概亲率原产结果

probs = gmm.predict_proba(X)print(probs[:5].round(3))[[0. 0.469 0. 0.531][1. 0. 0. 0. ][1. 0. 0. 0. ][0. 0. 0. 1. ][1. 0. 0. 0. ]]

编纂画gmm画边境线的变数

from matplotlib.patches import Ellipsedef draw_ellipse(position, covariance, ax=None, **kwargs):"""Draw an ellipse with a given position and covariance"""ax = ax or plt.gca# Convert covariance to principal axesif covariance.shape == (2, 2):U, s, Vt = np.linalg.svd(covariance)angle = np.degrees(np.arctan2(U[1, 0], U[0, 0]))width, height = 2 * np.sqrt(s)else:angle = 0width, height = 2 * np.sqrt(covariance)# Draw the Ellipsefor nsig in range(1, 4):ax.add_patch(Ellipse(position, nsig * width, nsig * height,angle, **kwargs))def plot_gmm(gmm, X, label=True, ax=None):ax = ax or plt.gcalabels = gmm.fit(X).predict(X)if label:ax.scatter(X[:, 0], X[:, 1], c=labels, s=40, cmap=‘viridis‘, zorder=2)else:ax.scatter(X[:, 0], X[:, 1], s=40, zorder=2)ax.axis(‘equal‘)w_factor = 0.2 / gmm.weights_.maxfor pos, covar, w in zip(gmm.means_, gmm.covariances_, gmm.weights_):draw_ellipse(pos, covar, alpha=w * w_factor) 在球形数据资料上的聚类结果 gmm = GaussianMixture(n_components=4, random_state=42)plot_gmm(gmm, X) 在侧向剪切数据资料上的聚类结果 gmm = GaussianMixture(n_components=4, covariance_type=‘full‘, random_state=42)plot_gmm(gmm, X_stretched)

GMM某种程度上是一个密度少于解律；也就是说，从高效率的角度考虑，

一个 GMM 意味着的结果并不是一个聚类建模，而是刻画数据资料原产的聚合概亲率建模。

非时域边境线的原因 # 构建非时域可分数据资料 from sklearn.datasets import make_moonsXmoon, ymoon = make_moons(200, noise=.05, random_state=0)plt.scatter(Xmoon[:, 0], Xmoon[:, 1]);

? 如果用做2个成份聚类（即降为了结果所设为2），基本没什么视觉效果

gmm2 = GaussianMixture(n_components=2, covariance_type=‘full‘, random_state=0)plot_gmm(gmm2, Xmoon)

? 如果所设为多个聚类成份

gmm16 = GaussianMixture(n_components=16, covariance_type=‘full‘, random_state=0)plot_gmm(gmm16, Xmoon, label=False)

这里采用 16 个拉普拉斯斜率的分离形基本型不是为了找到数据资料的分隔的簇，而是为了对转换成数据资料的各个方面原产建模。

原产变数的聚合建模可以聚合属于自己，与转换成数据资料相近的随机原产变数（聚合属于自己数据资料点）

用 GMM 意味着原始数据资料获的 16 个成份聚合的 400 个一新数据资料点

Xnew = gmm16.sample(400)Xnew[0][:5]Xnew = gmm16.sample(400)plt.scatter(Xnew[0][:, 0], Xnew[0][:, 1]);

作为一种聚合建模，GMM 透过了一种确定数据资料集给定成份存量的工具。

赤池信息量原则（Akaike information criterion) AIC 贝叶斯信息原则（Bayesian information criterion) BIC n_components = np.arange(1, 21)models = [GaussianMixture(n, covariance_type=‘full‘, random_state=0).fit(Xmoon)for n in n_components]plt.plot(n_components, [m.bic(Xmoon) for m in models], label=‘BIC‘)plt.plot(n_components, [m.aic(Xmoon) for m in models], label=‘AIC‘)plt.legend(loc=‘best‘)plt.xlabel(‘n_components‘);

仔细观察可得，在 8~12 个；大成份的时候，AIC 较小

评论者高效率一、定义解律

常用高效率选项方基本型为

平衡点定义疑虑：

定义稳定性、ROC斜率

一般来说不平衡点疑虑：

熟练亲率、复职亲率

对于二定义疑虑，常用的高效率是 f1 、 roc_auc

多定义疑虑，可用的高效率为 f1_weighted

一般用做平衡点定义疑虑（每个类比的必要性相同）

from sklearn.metrics import accuracy_scoreaccuracy_score(y_test, y_predict) #(真系数，得都是结论系数) 熟练亲率：准确得都是结论为1 的存量，占到，所有得都是结论为1的百分比 复职亲率：准确得都是结论为1 的存量，占到， 所有确实为1的百分比 # 到时确实系数，后得都是结论系数from sklearn.metrics import confusion_matrixconfusion_matrix(y_test, y_log_predict)from sklearn.metrics import precision_scoreprecision_score(y_test, y_log_predict)from sklearn.metrics import recall_scorerecall_score(y_test, y_log_predict)

多定义疑虑中的的重名时域

多定义结果的熟练亲率 from sklearn.metrics import precision_scoreprecision_score(y_test, y_predict, average="micro") 多定义疑虑中的的重名时域 from sklearn.metrics import confusion_matrixconfusion_matrix(y_test, y_predict) 清空矩形上定义准确的结果，可视转化查询其它定义偏差的原因比方说，横坐标为得都是结论系数，纵坐标为确实系数 cfm = confusion_matrix(y_test, y_predict)row_sums = np.sum(cfm, axis=1)err_matrix = cfm / row_sumsnp.fill_diagonal(err_matrix, 0)plt.matshow(err_matrix, cmap=plt.cm.gray)plt.show

F1-score是熟练亲率precision和复职亲率recall的调和平均数

from sklearn.metrics import f1_scoref1_score(y_test, y_predict)

可以通过调整电位，改变熟练亲率和复职亲率（配置文件电位为0）

更为有电位，但会提高熟练亲率，减很低复职亲率 减很低电位，但会减很低熟练亲率，提高复职亲率 # 送回去建模解律得都是结论赢取的佳绩# 这里是以 逻辑学重归解律 为例decision_score = log_reg.decision_function(X_test)# 调整电位为5y_predict_2 = np.array(decision_score>= 5, dtype=‘int‘)# 送回去的结果是0 、1 from sklearn.metrics import precision_recall_curveprecisions, recalls, thresholds = precision_recall_curve(y_test, decision_score)# 这里的decision_score是后面由建模对X_test得都是结论赢取的对象 画PR斜率 # 熟练亲率复职亲率斜率plt.plot(precisions, recalls)plt.show 将熟练亲率和复职亲率斜率，画在同一张图中的

忽略，当取“第二大的” threshold系数的时候，熟练亲率=1，复职亲率=0，

但是，这个第二大的threshold不会近似于的系数

因此thresholds但会少一个

plt.plot(thresholds, precisions[:-1], color=‘r‘)plt.plot(thresholds, recalls[:-1], color=‘b‘)plt.show

Reciver Operation Characteristic Curve

TPR： True Positive rate FPR： False Positive RateFPR=FPTN+FPFPR=FPTN+FP

画ROC斜率

from sklearn.metrics import roc_curvefprs, tprs, thresholds = roc_curve(y_test, decision_scores)plt.plot(fprs, tprs)plt.show

计计ROC斜率左侧的覆盖面积的变数

roc_ area_ under_ curve_score

from sklearn.metrics import roc_auc_scoreroc_auc_score(y_test, decision_scores)

斜率左侧的覆盖面积可用做相比较两个建模的不一

总之，后面说明的decision_score 是一个概亲率系数，如0 1 二定义疑虑，一定但会是将每个结果显示得都是结论为1的概亲率，

如某个结果显示的y_test为1，y_predict_probablity为0.875

每个的测试结果显示近似于一个得都是结论的概亲率系数

往往在建模fit启动便，都但会有附加的赢取概亲率的变数，如

model.predict_prob(X_test)

model.decision_function(X_test)

from sklearn.metrics import mean_squared_errormean_squared_error(y_test, y_predict) from sklearn.metrics import mean_absolute_errormean_absolute_error(y_test, y_predict) from sklearn.metrics import r2_scorer2_score(y_test, y_predict) import numpy as npimport matplot.pyplot as pltfrom sklearn.metrics import mean_squared_errordef plot_learning_curve(algo, X_train, X_test, y_train, y_test):train_score = test_score = for i in range(1, len(X_train)+1):algo.fit(X_train[:i], y_train[:i])y_train_predict = algo.predict(X_train[:i])train_score.append(mean_squared_error(y_train[:i], y_train_predict))y_test_predict = algo.predict(X_test)test_score.append(mean_squared_error(y_test, y_test_predict))plt.plot([i for i in range(1, len(X_train)+1)], np.sqrt(train_score), )plt.plot([i for i in range(1, len(X_train)+1)], np.sqrt(test_score), )plt.legendplt.axis([0,len(X_train)+1, 0, 4])plt.show# 调用plot_learning_curve(LinearRegression, X_train, X_test, y_train, y_test )。

宁波皮肤病专科医院
重庆男科医院哪里好
福州精神心理医院
延长阴茎
牙病治疗
男性阳痿
解酒药
产后妊娠纹