使用 Python 进行机器学习

使用 Python 进行机器学习 - 算法

机器学习算法大致可以分为两类 - 监督 和 无监督。本章详细讨论它们。

监督学习

该算法由目标或结果或因变量组成，该变量是根据给定的一组预测变量或自变量预测的。使用这些变量集，我们生成一个函数，将输入变量映射到所需的输出变量。训练过程持续进行，直到模型在训练数据上达到所需的准确度。

监督学习的例子 - 回归、决策树、随机森林、KNN、逻辑回归等。

无监督学习

在此算法中，没有要预测或估计的目标、结果或因变量。它用于将给定的数据集聚类为不同的组，广泛用于将客户细分为不同的组以进行特定的干预。 Apriori 算法和 K-means 是无监督学习的一些例子。

强化学习

使用该算法，机器被训练以做出特定决策。在这里，算法通过使用试错法和反馈方法不断地自我训练。该机器从过去的经验中学习，并尝试获取最佳的知识以做出准确的业务决策。

马尔可夫决策过程是强化学习的一个例子。

常见机器学习算法列表

以下是常用机器学习算法的列表，可应用于几乎任何数据问题 -

• 线性回归
• 逻辑回归
• 决策树
• 支持向量机
• 朴素贝叶斯
• 克尼恩
• K-均值
• 随机森林
• 降维算法
• 梯度提升算法，例如 GBM、XGBoost、LightGBM 和 CatBoost

本节详细讨论它们中的每一个 -

线性回归

线性回归用于根据连续变量估计现实世界的价值，例如房屋成本、通话次数、总销售额等。在这里，我们通过拟合最佳线来建立因变量和自变量之间的关系。这条最佳拟合线称为 回归线 并由线性方程表示 Y=a*X+b。

在这个等式中 -

Y——因变量

a – 坡度

X – 自变量

b – 拦截

这些系数 A 和 乙 基于最小化数据点与回归线之间距离的平方差之和而得出。

例子

理解线性回归的最好方法是考虑一个例子。假设我们被要求按体重递增的顺序将学生安排在班级中。通过观察学生并直观地分析他们的身高和体型，我们可以根据需要使用这些参数（即身高和体型）的组合来安排他们。这是现实世界的线性回归示例。我们已经发现身高和体格与体重之间存在某种关系，这与上面的等式类似。

线性回归的类型

线性回归主要有两种类型 - 简单线性回归 和 多元线性回归。简单线性回归的特征在于一个自变量，而多元线性回归的特征在于多个自变量。在寻找最佳拟合线时，您可以拟合多项式或曲线回归。您可以使用以下代码来实现此目的。

导入 matplotlib.pyplot as plt plt.scatter(X, Y) yfit = [a + b * xi for xi in X] plt.plot(X, yfit)

构建线性回归器

回归是估计输入数据和连续值输出数据之间关系的过程。这些数据通常采用实数形式，我们的目标是估计控制从输入到输出的映射的基础函数。

考虑输入和输出之间的映射，如下所示 -

1 --> 2 3 --> 6 4.3 --> 8.6 7.1 --> 14.2

您可以通过分析模式轻松估计输入和输出之间的关系。我们可以观察到，在每种情况下，输出都是输入值的两倍，因此转换为 - f(x) = 2x

线性回归是指使用输入变量的线性组合来估计相关函数。前面的示例是由一个输入变量和一个输出变量组成的示例。

线性回归的目标是提取将输入变量与输出变量联系起来的相关线性模型。其目的是使用线性函数最小化实际输出与预测输出之间的差异平方和。这个方法称为 普通最小二乘。您可能会假设一条曲线更适合这些点，但线性回归不允许这样做。线性回归的主要优点是它并不复杂。您还可能会在非线性回归中找到更准确的模型，但它们会更慢。这里，模型尝试使用直线来近似输入数据点。

让我们了解如何在 Python 中构建线性回归模型。

假设您已获得一个数据文件，名为 data_singlevar.txt。它包含以逗号分隔的行，其中第一个元素是输入值，第二个元素是与该输入值对应的输出值。您应该使用它作为输入参数 -

假设一组点的最佳拟合线是 -

y = a + b * x

其中 b = ( sum(xi * yi) - n * xbar * ybar ) / sum((xi - xbar)^2)

a = 纵坐标 - b * 横坐标

为此目的使用以下代码 -

# 样本点 X = [0, 6, 11, 14, 22] Y = [1, 7, 12, 15, 21] # 求解 a 和 b def best_fit(X, Y): xbar = sum(X)/ len(X) ybar = sum(Y)/len(Y) n = len(X) # 或 len(Y) numer = sum([xi*yi for xi,yi in zip(X, Y)]) - n * xbar * ybar denum = sum([xi**2 for xi in X]) - n * xbar**2 b = numer / denum a = ybar - b * xbar print('最佳拟合线:\ny = {: .2f} + {:.2f}x'.format(a, b)) return a, b # 解 a, b = best_fit(X, Y) #最佳拟合线: #y = 0.80 + 0.92x # 绘图点并拟合线 import matplotlib.pyplot as plt plt.scatter(X, Y) yfit = [a + b * xi for xi in X] plt.plot(X, yfit) plt.show() 最佳拟合线： y = 1.48 + 0.92x

如果运行上面的代码，您可以观察输出图，如下所示 -

请注意，此示例仅使用糖尿病数据集的第一个特征，以便说明此回归技术的二维图。可以在图中看到这条直线，显示线性回归如何尝试绘制一条直线，以最好地最小化数据集中观察到的响应与线性近似预测的响应之间的残差平方和。

您可以使用下面所示的程序代码计算系数、残差平方和和方差得分 -

import matplotlib.pyplot as plt import numpy as np from sklearn import datasets, Linear_model from sklearn.metrics importmean_squared_error, r2_score # 加载糖尿病数据集diabetes = datasets.load_diabetes() # 仅使用一个特征diabetes_X =diabetes.data[:, np .newaxis, 2] # 将数据拆分为训练/测试集糖尿病_X_train = 糖尿病_X[:-30] 糖尿病_X_test = 糖尿病_X[-30:] # 将目标拆分为训练/测试集糖尿病_y_train = 糖尿病.target[:-30] 糖尿病_y_test =糖尿病.target[-30:] # 创建线性回归对象 regr = Linear_model.LinearRegression() # 使用训练集训练模型 regr.fit(diabetes_X_train,diabetes_y_train) # 使用测试集进行预测diabetes_y_pred = regr.predict( diabetes_X_test) # 系数 print('Coefficients: \n', regr.coef_) # 均方误差 print("Mean squared error: %.2f" %mean_squared_error(diabetes_y_test,diabetes_y_pred)) # 解释方差分数：1 是完美的预测 print('方差分数: %.2f' % r2_score(diabetes_y_test,diabetes_y_pred)) # 绘制输出 plt.scatter(diabetes_X_test,diabetes_y_test, color = 'black') plt.plot(diabetes_X_test,diabetes_y_pred, color = 'blue',线宽 = 3) plt.xticks(()) plt.yticks(()) plt.show()

执行上面给出的代码后，您可以观察到以下输出 -

为IPython交互环境自动创建的模块（'系数：\ n'，数组（[941.43097333]））均方误差：3035.06方差分数：0.41

逻辑回归

逻辑回归是机器学习从统计学中借用的另一种技术。它是二元分类问题（即具有两个类值的问题）的首选方法。

顾名思义，它是一种分类算法，而不是回归算法。它用于根据给定的一组自变量估计离散值或 0/1、Y/N、T/F 等值。它通过将数据拟合到 logit 函数来预测事件发生的概率。因此，它也被称为 逻辑回归。由于它预测概率，因此其输出值介于 0 和 1 之间。

例子

让我们通过一个简单的例子来理解这个算法。

假设有一个谜题需要解决，只有两种结果场景——要么有解决方案，要么没有。现在假设，我们有各种各样的谜题来测试一个人擅长哪些科目。结果可能是这样的——如果给出一个三角难题，一个人可能有 80% 的可能解决它。另一方面，如果给出一个地理难题，该人解决它的可能性可能只有 20%。这就是逻辑回归可以帮助解决的地方。根据数学，结果的对数赔率表示为预测变量的线性组合。

赔率 = p/ (1-p) = 事件发生的概率 / 事件不发生的概率 ln(odds) = ln(p/(1-p)) ; ln 是以“e”为底的对数。 logit(p) = ln(p/(1-p)) = b0+b1X1+b2X2+b3X3....+bkXk

注意上面的 p 是感兴趣特征存在的概率。它选择的参数可以最大化观察样本值的可能性，而不是最小化误差平方和（如普通回归）。

请注意，取对数是复制阶跃函数的最佳数学方法之一。

在进行逻辑回归时，以下几点可能值得注意 -

• 它与回归类似，其目标是找到加权每个输入变量的系数值。

• 与线性回归不同，输出的预测是使用称为逻辑函数的非线性函数找到的。

• 逻辑函数看起来像一个大“S”，会将任何值更改为 0 到 1 的范围。这很有用，因为我们可以对逻辑函数的输出应用规则，将值分配给 0 和 1 并预测类别值。

• 根据逻辑回归模型的学习方式，它所做的预测也可以用作给定数据实例属于 0 类或 1 类的概率。这对于需要为预测提供更多推理的问题非常有用。

• 与线性回归一样，当去除输出变量的不相关属性并去除相似属性时，逻辑回归效果更好。

以下代码显示如何开发逻辑表达式图，其中使用逻辑曲线将合成数据集分为 0 或 1 值，即第一类或第二类。

import numpy as np import matplotlib.pyplot as plt from sklearn import Linear_model # 这是测试集，它是一条带有一些高斯噪声的直线 xmin, xmax = -10, 10 n_samples = 100 np.random.seed(0) X = np.random.normal(size = n_samples) y = (X > 0).astype(np.float) X[X > 0] *= 4 X += .3 * np.random.normal(size = n_samples) X = X[:, np.newaxis] # 运行分类器 clf = Linear_model.LogisticRegression(C=1e5) clf.fit(X, y) # 并绘制结果 plt.figure(1, Figsize = (4, 3)) plt.clf() plt.scatter(X.ravel(), y, color='black', zorder=20) X_test = np.linspace(-10, 10, 300) def model(x): return 1 / ( 1 + np.exp(-x)) 损失 = 模型(X_test * clf.coef_ + clf.intercept_).ravel() plt.plot(X_test, 损失, 颜色='蓝色', 线宽=3) ols = 线性_模型。 LinearRegression() ols.fit(X, y) plt.plot(X_test, ols.coef_ * X_test + ols.intercept_, 线宽=1) plt.axhline(.5, color='.5') plt.ylabel(' y') plt.xlabel('X') plt.xticks(范围(-10, 10)) plt.yticks([0, 0.5, 1]) plt.ylim(-.25, 1.25) plt.xlim(- 4, 10) plt.legend(('逻辑回归模型', '线性回归模型'), loc="右下", fontsize='小') plt.show()

输出图如下所示 -

决策树算法

它是一种监督学习算法，主要用于分类问题。它适用于离散和连续因变量。在此算法中，我们将总体分为两个或多个同质集合。这是根据最重要的属性来完成的，以尽可能形成不同的组。

决策树广泛应用于机器学习中，涵盖分类和回归。在决策分析中，决策树用于直观、明确地表示决策和决策制定。它使用树状决策模型。

绘制决策树时，根在顶部，分支在底部。在图像中，粗体文本表示条件/内部节点，根据该条件/内部节点，树分成分支/边缘。不再分裂的分支末端是决策/叶子。

例子

考虑一个使用泰坦尼克号数据集来预测乘客是否能生存的示例。下面的模型使用数据集中的 3 个特征/属性/列，即性别、年龄和 sibsp（配偶/子女数量）。在这种情况下，乘客是否死亡或幸存，分别表示为红色和绿色文本。

在一些例子中，我们看到人口根据多个属性被分为不同的组，以确定“他们是否做了某事”。为了将人口分成不同的异质群体，它使用了各种技术，如基尼系数、信息增益、卡方、熵等。

了解决策树工作原理的最佳方法是玩 Jezzball——微软的一款经典游戏。本质上，在这个游戏中，你有一个带有移动墙壁的房间，你需要创建墙壁，以便在没有球的情况下清除最大区域。

因此，每次您用墙分隔房间时，您都在尝试在同一个房间内创建 2 个不同的群体。决策树以非常相似的方式工作，将总体划分为尽可能不同的组。

观察下面给出的代码及其输出 -

#开始实现 import pandas as pd import matplotlib.pyplot as plt import numpy as np import seaborn as sns %matplotlib inline from sklearn import tree df = pd.read_csv("iris_df.csv") df.columns = ["X1", " X2", "X3","X4", "Y"] df.head() #implementation from sklearn.cross_validation import train_test_split Decision = tree.DecisionTreeClassifier(criterion="gini") X = df.values[:, 0: 4] Y = df.values[:, 4] trainX, testX, trainY, testY = train_test_split( X, Y, test_size = 0.3) Decision.fit(trainX, trainY) print("准确率：\n", Decision.score (testX, testY)) #可视化 from sklearn.externals.six import StringIO from IPython.display import Image import pydotplus as pydot dot_data = StringIO() tree.export_graphviz(decision, out_file=dot_data) graph = pydot.graph_from_dot_data(dot_data.getvalue ()) 图像(graph.create_png())

输出

准确度：0.955555555556

例子

这里我们使用钞票认证数据集来了解准确性。

# 使用来自随机导入种子的钞票数据集 from random import randrange from csv import reader # 加载 CSV 文件 filename ='data_banknote_authentication.csv' def load_csv(filename): file = open(filename, "rb")lines = reader( file) dataset = list(lines) return dataset # 将字符串列转换为浮点数 def str_column_to_float(dataset, column): for row in dataset: row[column] = float(row[column].strip()) # 将数据集拆分为k 折叠 def cross_validation_split(dataset, n_folds): dataset_split = list() dataset_copy = list(dataset) Fold_size = int(len(dataset) / n_folds) for i in range(n_folds): Fold = list() while len(fold) = max_深度：node['left'], node['right'] = to_terminal (left), to_terminal(right) return # 处理左子节点 if len(left) <= min_size: node['left'] = to_terminal(left) else: node['left'] = get_split(left) split(node[ 'left'], max_depth, min_size, height+1) # 处理右子节点 if len(right) <= min_size: node['right'] = to_terminal(right) else: node['right'] = get_split(right) split(node['right'], max_depth, min_size, height+1) # 构建决策树 def build_tree(train, max_depth, min_size): root = get_split(train) split(root, max_depth, min_size, 1) return root # 使用决策树进行预测 def Predict(node, row): if row[node['index']] < node['value']: if isinstance(node['left'], dict): return Predict(节点['左']，行）否则：返回节点['左']否则：如果isinstance（节点['右']，字典）：返回预测（节点['右']，行）否则：返回节点[ 'right'] # 分类和回归树算法 def Decision_tree(train, test, max_depth, min_size): tree = build_tree(train, max_depth, min_size)Predictions = list() for row in test: Prediction = Predict(tree, row) Predictions.append(prediction) return(predictions) # 测试钞票数据集 seed(1) # 加载并准备数据 filename = 'data_banknote_authentication.csv' dataset = load_csv(filename) # 将字符串属性转换为整数 for i in range(len (dataset[0])): str_column_to_float(dataset, i) # 评估算法 n_folds = 5 max_深度 = 5 min_size = 10 分数 =valuate_algorithm(dataset, Decision_tree, n_folds, max_depth, min_size) print('Scores: %s' % 分数) print('平均准确度: %.3f%%' % (sum(scores)/float(len(scores))))

当您执行上面给出的代码时，您可以观察输出如下 -

分数：[95.62043795620438、97.8102189781022、97.8102189781022、94.52554744525547、98.90510948905109] 平均准确度：96.934%

支持向量机 (SVM)

支持向量机，也称为 SVM，是众所周知的监督分类算法，可分离不同类别的数据。

通过优化线对这些向量进行分类，使得每个组中最近的点彼此相距最远。

该向量默认是线性的，并且通常也被可视化为线性的。但是，如果内核类型从默认类型“高斯”或线性更改，则向量也可以采用非线性形式。

它是一种分类方法，我们将每个数据项绘制为 n 维空间中的一个点（其中 n 是特征数量），每个特征的值是特定坐标的值。

例如，如果我们只有两个特征，例如 高度 和 头发长度 对于一个人，我们首先应该在二维空间中绘制这两个变量，其中每个点都有两个坐标，称为支持向量。观察下图以便更好地理解 -

现在，找到一些线将数据划分为两个不同分类的数据组。这条线使得到两组中每组中最近的点的距离将是最远的。

在上面所示的示例中，将数据分为两个不同分类组的线是黑线，因为两个最近的点距该线最远。这条线是我们的分类器。然后，根据测试数据落在线两侧的位置，我们可以对新数据进行分类。

from sklearn import svm df = pd.read_csv('iris_df.csv') df.columns = ['X4', 'X3', 'X1', 'X2', 'Y'] df = df.drop(['X4') ', 'X3'], 1) df.head() from sklearn.cross_validation import train_test_split support = svm.SVC() X = df.values[:, 0:2] Y = df.values[:, 2] trainX , testX, trainY, testY = train_test_split( X, Y, test_size = 0.3) sns.set_context('notebook', font_scale=1.1) sns.set_style('ticks') sns.lmplot('X1','X2', scatter =True, fit_reg=False, data=df, Hue='Y') plt.ylabel('X2') plt.xlabel('X1')

当您运行上面显示的代码时，您可以注意到以下输出和绘图 -

文本(0.5,27.256,'X1')

朴素贝叶斯算法

它是一种基于贝叶斯定理的分类技术，假设预测变量是独立的。简而言之，朴素贝叶斯分类器假设类中特定特征的存在与任何其他特征的存在无关。

例如，如果水果颜色为橙色、圆形且直径约为 3 英寸，则可将其视为橙色。即使这些特征相互依赖或依赖于其他特征的存在，朴素贝叶斯分类器也会考虑所有这些特征独立地影响该水果是橙子的概率。

朴素贝叶斯模型很容易制作，对于非常大的数据集特别有用。除了简单之外，朴素贝叶斯的性能甚至优于非常先进的分类方法。

贝叶斯定理提供了一种根据 P(c)、P(x) 和 P(x|c) 计算后验概率 P(c|x) 的方法。观察此处提供的等式： P(c/x) = P(x/c)P(c)/P(x)

在哪里，

P(c|x) 是给定预测变量（属性）的类（目标）的后验概率。

P(c) 是类别的先验概率。

P(x|c) 是似然性，是给定类别的预测变量的概率。

P(x) 是预测变量的先验概率。

为了更好地理解，请考虑下面给出的示例 -

假设训练数据集为 天气 以及对应的目标变量 玩。现在，我们需要根据天气情况来分类玩家是否参加比赛。为此，您必须采取以下步骤 -

步骤1 − 将数据集转换为频数表。

第2步 − 通过查找概率（如阴天概率 = 0.29 和播放概率为 0.64）来创建似然表。

步骤3 − 现在，使用朴素贝叶斯方程计算每个类别的后验概率。后验概率最高的类别是预测的结果。

问题 − 如果天气晴朗，球员就会参加比赛，这种说法正确吗？

解决方案 − 我们可以使用上面讨论的方法来解决它，所以 P(Yes | Sunny) = P（晴天 | 是） * P（是）/ P（晴天）

这里我们有，P（晴天|是）= 3/9 = 0.33，P（晴天）= 5/14 = 0.36，P（是）= 9/14 = 0.64

现在，P(Yes | Sunny) = 0.33 * 0.64 / 0.36 = 0.60，概率较高。

朴素贝叶斯使用类似的方法根据各种属性来预测不同类别的概率。该算法主要用于文本分类和具有多个类别的问题。

以下代码显示了朴素贝叶斯实现的示例 -

导入 csv 导入随机导入数学 def loadCsv(filename):lines = csv.reader(open(filename, "rb")) dataset = list(lines) for i in range(len(dataset)): dataset[i] = [ float(x) for x in dataset[i]] 返回数据集 def splitDataset(dataset, splitRatio): trainSize = int(len(dataset) * splitRatio) trainSet = [] copy = list(dataset) while len(trainSet) < trainSize ：index = random.randrange（len（copy））trainSet.append（copy.pop（index））返回[trainSet，copy] def septeparByClass（数据集）：分离= {} for i in range（len（数据集））：向量 = 数据集[i] if (向量[-1] 未分隔): 分隔[向量[-1]] = []分隔[向量[-1]].append(向量) 返回分隔的 def 平均值(数字): return sum(数字)/float(len(数字)) def stdev(数字): avg = 均值(数字) 方差 = sum([pow(x-avg,2) 对于数字中的 x])/float(len(数字) )-1) return math.sqrt(variance) def summarise(dataset): summaries = [(mean(attribute), stdev(attribute)) for attribute in zip(*dataset)] def summarizeByClass(dataset): seped = septemberByClass( dataset) summaries = {} 对于 classValue，separated.iteritems() 中的实例： summaries[classValue] = summarise(instances) 返回摘要 defcalculateProbability(x,mean,stdev):exponent = math.exp(-(math.pow( x-mean,2)/(2*math.pow(stdev,2)))) return (1 / (math.sqrt(2*math.pi) * stdev)) * 指数 defcalculateClassProbabilities(summaries, inputVector):概率 = {} for classValue, classSummaries in summaries.iteritems(): 概率[classValue] = 1 for i in range(len(classSummaries)): Mean, stdev = classSummaries[i] x = inputVector[i] 概率[classValue] *=calculateProbability(x,mean,stdev)返回概率defpredict(summaries,inputVector)：概率=calculateClassProbativity(summaries,inputVector)bestLabel，bestProb=None，classValue为-1，概率在probabilities.iteritems()中：如果bestLabel是无或概率 > bestProb： bestProb = 概率 bestLabel = classValue return bestLabel def getPredictions(summaries, testSet): 预测 = [] for i in range(len(testSet)): result = Predict(summaries, testSet[i]) 预测。附加（结果）返回预测 def getAccuracy（testSet，预测）：正确= 0 for i in range（len（testSet））：如果testSet [i] [-1] ==预测[i]：正确+ = 1返回（正确/浮动（len（testSet）））* 100.0 def main（）：文件名='pima-indians-diabetes.data.csv'splitRatio = 0.67数据集= loadCsv（文件名）trainingSet，testSet = splitDataset（数据集，splitRatio）打印('将 {0} 行拆分为 train = {1} 和 test = {2} 行').format(len(dataset), len(trainingSet), len(testSet)) # 准备模型摘要 = summariseByClass(trainingSet) #测试模型预测 = getPredictions(summaries, testSet) 准确度 = getAccuracy(testSet, Predictions) print('准确度：{0}%').format(accuracy) main()

当您运行上面给出的代码时，您可以观察到以下输出 -

将 1372 行拆分为训练 = 919 行和测试 = 453 行准确率：83.6644591611%

KNN（K 最近邻）

K-Nearest Neighbors，简称KNN，是一种专门用于分类的监督学习算法。这是一个简单的算法，存储所有可用的案例并通过其 k 邻居的多数投票对新案例进行分类。分配给该类的情况是通过距离函数测量的 K 个最近邻中最常见的情况。这些距离函数可以是欧几里得距离、曼哈顿距离、闵可夫斯基距离和汉明距离。前三个函数用于连续函数，第四个函数（汉明）用于分类变量。如果 K = 1，则该案例将简单地分配给其最近邻居的类别。有时，在执行 KNN 建模时选择 K 是一个挑战。

该算法查看不同的质心并使用某种函数（通常是欧几里得函数）比较距离，然后分析这些结果并将每个点分配给组，以便优化与所有最接近的点一起放置。

您可以使用 KNN 来解决分类和回归问题。但在业界，它在分类问题上的应用更为广泛。 KNN 可以很容易地映射到我们的现实生活中。

在选择 KNN 之前，您必须注意以下几点 -

• KNN 的计算成本很高。

• 变量应该标准化，否则较高范围的变量可能会产生偏差。

• 在进行 KNN 之前，更多地进行预处理阶段，例如离群值、噪声消除

观察以下代码可以更好地理解 KNN -

#Importing Libraries from sklearn.neighbors import KNeighborsClassifier #假设你有训练数据集的X（预测器）和Y（目标）以及test_dataset的x_test(预测器) #创建KNeighbors分类器对象模型 KNeighborsClassifier(n_neighbors=6) #默认值n_neighbors is 5 # 使用训练集训练模型并检查分数 model.fit(X, y) #Predict 输出预测= model.predict(x_test) from sklearn.neighbors import KNeighborsClassifier df = pd.read_csv('iris_df.csv' ) df.columns = ['X1', 'X2', 'X3', 'X4', 'Y'] df = df.drop(['X4', 'X3'], 1) df.head() sns .set_context('笔记本', font_scale=1.1) sns.set_style('ticks') sns.lmplot('X1','X2', scatter=True, fit_reg=False, data=df, Hue='Y') plt .ylabel('X2') plt.xlabel('X1') from sklearn.cross_validation import train_test_split Neighbors = KNeighborsClassifier(n_neighbors=5) X = df.values[:, 0:2] Y = df.values[:, 2 ] trainX, testX, trainY, testY = train_test_split( X, Y, test_size = 0.3) Neighbors.fit(trainX, trainY) print('准确度: \n', Neighbors.score(testX, testY)) pred = Neighbors.predict （测试X）

上面给出的代码将产生以下输出 -

('准确度：\n', 0.75555555555555554)

K-均值

它是一种处理聚类问题的无监督算法。其过程遵循一种简单易行的方法，通过一定数量的簇（假设 k 个簇）对给定数据集进行分类。集群内的数据点是同质的，并且与对等组是异构的。

K-means 如何形成聚类

K 均值在下面给出的步骤中形成聚类 -

• K-均值选择 k 每个簇的点数称为质心。

• 每个数据点形成一个具有最近质心的簇，即 k 个簇。

• 根据现有集群成员查找每个集群的质心。这里我们有新的质心。

当我们有了新的质心时，重复步骤 2 和 3。找到每个数据点与新质心的最近距离，并与新的 k 簇相关联。重复这个过程直到收敛，即质心不再改变。

K值的确定

在 K 均值中，我们有簇，每个簇都有自己的质心。质心与簇内数据点之间的差值平方和构成该簇的平方值之和。另外，当将所有簇的平方值之和相加时，它变为簇解的平方值之和内的总和。

我们知道，随着簇数量的增加，该值不断减小，但如果绘制结果，您可能会发现平方距离之和急剧减小到 k 的某个值，然后此后速度减慢。在这里，我们可以找到最佳的簇数。

观察以下代码 -

导入 numpy 作为 np 导入 matplotlib.pyplot 作为 plt 从 matplotlib 导入样式 style.use("ggplot") 从 sklearn.cluster 导入 KMeans x = [1, 5, 1.5, 8, 1, 9] y = [2, 8, 1.8, 8, 0.6, 11] plt.scatter(x,y) plt.show() X = np.array([ [1, 2], [5, 8], [1.5, 1.8], [8, 8 ], [1, 0.6], [9, 11]]) kmeans = KMeans(n_clusters=2) kmeans.fit(X) 质心 = kmeans.cluster_centers_ labels = kmeans.labels_ print(centroids) print(labels) 颜色 = [ "g.","r.","c.","y."] for i in range(len(X)): print("坐标:",X[i], "标签:", labels[ i]) plt.plot(X[i][0], X[i][1], 颜色[标签[i]], 标记大小 = 10) plt.scatter(centroids[:, 0],centroids[:, 1]，标记 =“x”，s=150，线宽 = 5，zorder = 10) plt.show()

当您运行上面给出的代码时，您可以看到以下输出 -

[ [ 1.16666667 1.46666667] [ 7.33333333 9. ] ] [0 1 0 1 0 1] ('坐标:', array([ 1., 2.]), '标签:', 0) ('坐标:', array ([ 5., 8.]), '标签：', 1) ('坐标：', array([ 1.5, 1.8]), '标签：', 0) ('坐标：', array([ 8. , 8.]), '标签:', 1) ('坐标:', array([ 1., 0.6]), '标签:', 0) ('坐标:', array([ 9., 11. ]), '标签:', 1)

这是另一个供您理解的代码 -

从 sklearn.cluster 导入 KMeans df = pd.read_csv('iris_df.csv') df.columns = ['X1', 'X2', 'X3', 'X4', 'Y'] df = df.drop([ 'X4', 'X3'], 1) df.head() from sklearn.cross_validation import train_test_split kmeans = KMeans(n_clusters = 3) X = df.values[:, 0:2] kmeans.fit(X) df[ 'Pred'] = kmeans.predict(X) df.head() sns.set_context('笔记本', font_scale = 1.1) sns.set_style('ticks') sns.lmplot('X1','X2', scatter = True，fit_reg = False，data = df，hue = 'Pred'）

这是上面代码的输出 -

随机森林

随机森林是一种流行的监督集成学习算法。 “集成”意味着它需要一群“弱学习者”，让他们一起工作形成一个强大的预测器。在这种情况下，弱学习器都是随机实现的决策树，它们聚集在一起形成强预测器——随机森林。

观察以下代码 -

从 sklearn.ensemble 导入 RandomForestClassifier df = pd.read_csv('iris_df.csv') df.columns = ['X1', 'X2', 'X3', 'X4', 'Y'] df.head() from sklearn .cross_validation 导入 train_test_split 森林 = RandomForestClassifier() X = df.values[:, 0:4] Y = df.values[:, 4] trainX, testX, trainY, testY = train_test_split( X, Y, test_size = 0.3) 森林.fit(trainX, trainY) print('准确率: \n',forest.score(testX, testY)) pred =forest.predict(testX)

上面给出的代码的输出是 -

('准确度：\n', 1.0)

集成方法的目标是结合使用给定学习算法构建的多个基本估计器的预测，以提高单个估计器的通用性/鲁棒性。

这 sklearn.ensemble 模块包括两种基于随机决策树的平均算法 - 随机森林算法 和 额外树法。这两种算法都是专门为树设计的扰动组合技术 [B1998]。这意味着通过在分类器构造中引入随机性来创建一组多样化的分类器。整体的预测作为各个分类器的平均预测给出。

森林分类器必须配备两个数组 - 一个大小为 [n_samples, n_features] 的稀疏或密集数组 X，保存训练样本，以及一个大小为 [n_samples] 的数组 Y，保存训练样本的目标值（类标签），如下面的代码所示 -

>>> from sklearn.ensemble import RandomForestClassifier >>> X = [[0, 0], [1, 1]] >>> Y = [0, 1] >>> clf = RandomForestClassifier(n_estimators = 10) >>> > clf = clf.fit(X, Y)

与决策树一样，树的森林也扩展到多输出问题（如果 Y 是大小为 [n_samples, n_outputs] 的数组）。

与原始出版物 [B2001] 相比， scikit学习 实现通过平均分类器的概率预测来组合分类器，而不是让每个分类器投票给单个类。

随机森林是决策树集合的商标术语。在随机森林中，我们有一组决策树，称为“森林”。为了根据属性对新对象进行分类，每棵树都会给出一个分类，我们说树为该类“投票”。森林选择得票最多的分类（在森林中的所有树木中）。

每棵树的种植和生长如下 -

• 如果训练集中的案例数为 N，则随机抽取 N 个案例的样本，但进行放回。该样本将作为种植树的训练集。

• 如果有 M 个输入变量，则指定数字 m<

• 每棵树都尽可能地生长。没有修剪。

降维算法

降维是另一个常见的无监督学习任务。有些问题可能包含数万甚至数百万个输入或解释变量，处理和计算这些变量的成本可能很高。此外，如果某些输入变量捕获噪声或与潜在关系不相关，则程序的泛化能力可能会降低。

降维是寻找导致输出或响应变量变化最大的输入变量的过程。降维有时也用于可视化数据。很容易将回归问题可视化，例如根据房产的大小预测房产的价格，其中房产的大小可以沿图的 x 轴绘制，房产的价格可以沿 y 轴绘制。同样，当添加第二个解释变量时，很容易可视化房地产价格回归问题。例如，可以在 z 轴上绘制属性中的房间数量。然而，具有数千个输入变量的问题变得不可能可视化。

降维将一组非常大的解释变量输入减少为一组较小的输入变量，从而保留尽可能多的信息。

PCA 是一种降维算法，可以为数据分析做有用的事情。最重要的是，在处理数百或数千个不同的输入变量时，它可以显着减少模型中涉及的计算数量。由于这是一项无监督学习任务，用户仍然需要分析结果并确保保留 95% 左右的原始数据集行为。

请观察以下代码以更好地理解 -

来自 sklearn 导入分解 df = pd.read_csv('iris_df.csv') df.columns = ['X1', 'X2', 'X3', 'X4', 'Y'] df.head() 来自 sklearn 导入分解pca = 分解.PCA() fa = 分解.FactorAnalysis() X = df.values[:, 0:4] Y = df.values[:, 4] 训练, test = train_test_split(X,test_size = 0.3) train_reduced = pca.fit_transform(train) test_reduced = pca.transform(test) pca.n_components_

您可以看到上面给出的代码的以下输出 -

4升

在过去 5 年中，每个可能级别和点的数据捕获量呈指数级增长。政府机构/研究组织/企业不仅推出了新的数据源，而且还在多个点和阶段捕获非常详细的数据。

例如，电子商务公司正在捕获有关客户的更多详细信息，例如他们的人口统计数据、浏览历史记录、他们的喜好、购买历史记录、反馈和其他一些详细信息，以便为他们提供定制化的关注。现在可用的数据可能有数千个特征，在保留尽可能多的信息的同时减少这些特征是一个挑战。在这种情况下，降维会有很大帮助。

增强算法

“Boosting”一词指的是一系列将弱学习者转变为强学习者的算法。让我们通过解决垃圾邮件识别问题来理解这个定义，如下所示 -

应遵循什么程序将电子邮件分类为垃圾邮件或不分类？在最初的方法中，我们将使用以下标准来识别“垃圾邮件”和“非垃圾邮件”电子邮件：

• 电子邮件只有一个图像文件（广告图像），这是一封垃圾邮件

• 电子邮件只有链接，这是垃圾邮件

• 电子邮件正文由“您赢得了 $ xxxxxx 奖金”之类的句子组成，这是垃圾邮件

• 来自我们官方域名“Tutorialspoint.com”的电子邮件，不是垃圾邮件

• 来自已知来源的电子邮件，不是垃圾邮件

上面，我们定义了一些规则来将电子邮件分类为“垃圾邮件”或“非垃圾邮件”。然而，这些规则单独的强度不足以成功地将电子邮件分类为“垃圾邮件”或“非垃圾邮件”。因此，这些规则被称为 弱学习者。

为了将弱学习器转换为强学习器，我们使用以下方法结合每个弱学习器的预测 -

• 使用平均/加权平均
• 考虑投票率较高的预测

例如，假设我们定义了 7 个弱学习器。在这 7 个中，5 个被投票为“垃圾邮件”，2 个被投票为“不是垃圾邮件”。在这种情况下，默认情况下，我们会将电子邮件视为垃圾邮件，因为我们对“垃圾邮件”的投票较高 (5)。

怎么运行的

Boosting 将弱学习器或基础学习器结合起来形成强规则。本节将向您解释提升如何识别弱规则。

为了找到弱规则，我们应用具有不同分布的基础学习（ML）算法。每次应用基础学习算法时，它都会生成一个新的弱预测规则。这多次使用迭代过程。经过多次迭代后，Boosting 算法将这些弱规则组合成一个强预测规则。

要为每轮选择正确的分布，请按照给定的步骤操作 -

步骤1 − 基础学习器获取所有分布并为每个分布分配相同的权重。

第2步 − 如果存在由第一基础学习算法引起的任何预测误差，那么我们对具有预测误差的观测值给予更高的权重。然后，我们应用下一个基础学习算法。

我们迭代步骤2，直到达到基础学习算法的极限或达到更高的精度。

最后，它结合弱学习器的输出并形成强学习器，最终提高模型的预测能力。 Boosting 更关注那些由于规则较弱而被错误分类或具有较高错误的示例。

Boosting 算法的类型

用于增强算法的引擎有多种类型 - 决策树桩、边缘最大化分类算法等。这里列出了不同的增强算法 -

• AdaBoost（自适应增强）
• 梯度树提升
• XGBoost

本节重点介绍 AdaBoost 和梯度提升，然后是它们各自的提升算法。

阿达助推器

请观察下图，该图解释了 Ada-boost 算法。

解释如下 -

盒子1 − 您可以看到我们为每个数据点分配了相同的权重，并应用决策树桩将它们分类为 + (加） 或者 - （减）。决策树桩 (D1) 在左侧创建了一条垂直线来对数据点进行分类。这条垂直线将三个+（加）错误地预测为-（减）。因此，我们将为这三个+（加号）分配更高的权重，并应用另一个决策树桩。

盒子2 − 在这里，可以看到 3（错误预测）的大小 + (加）数据点与其余数据点相比更大。在这种情况下，第二个决策树桩 (D2) 将尝试正确预测它们。现在，该框右侧的垂直线（D2）已分类了三个错误分类的+（加）正确。但它又犯了分类错误。这次是三个 -(减） 数据点。同样，我们将为这三个分配更高的权重 – (减）数据点并应用另一个决策树桩。

方框3 − 这里，三个 – (减) 数据点被赋予更高的权重。应用决策树桩 (D3) 来正确预测这些错误分类的观测值。这次生成一条水平线来分类 + (加） 和 - （减）基于错误分类的观测值的较高权重的数据点。

方框4 − 在这里，我们加入了 D1、D2 和 D3，形成了与单个弱学习器相比具有复杂规则的强预测。可以看出，与任何单个弱学习器相比，该算法对这些观察结果进行了很好的分类。

AdaBoost 或自适应增强 − 它的工作原理与上面讨论的类似。它在不同的加权训练数据上拟合一系列弱学习器。它首先预测原始数据集，并对每个观察值赋予相同的权重。如果使用第一个学习器的预测不正确，那么它会给预测错误的观察结果赋予更高的权重。作为一个迭代过程，它会继续添加学习者，直到达到模型数量或准确性的限制。

大多数情况下，我们将决策标记与 AdaBoost 一起使用。但是，如果任何机器学习算法接受训练数据集的权重，我们就可以使用它作为基础学习器。我们可以使用 AdaBoost 算法来解决分类和回归问题。

您可以使用以下 Python 代码来实现此目的 -

#for 分类 from sklearn.ensemble import AdaBoostClassifier #for 回归 from sklearn.ensemble import AdaBoostRegressor from sklearn.tree import DecisionTreeClassifier dt = DecisionTreeClassifier() clf = AdaBoostClassifier(n_estimators=100, base_estimator=dt,learning_rate=1) #这里我们使用了决策树作为基本估计器；任何 ML 学习器如果接受样本权重 clf.fit(x_train,y_train) 都可以用作基础 #estimator

调整参数

可以调整参数来优化算法的性能，调整的关键参数是 -

n_估计器 − 这些控制弱学习器的数量。

学习率 − 这控制了弱学习器在最终组合中的贡献。 Learning_rate 和 n_estimators 之间存在权衡。

基本估计器 − 这些有助于指定不同的机器学习算法。

还可以调整基础学习器的参数以优化其性能。

梯度提升

在梯度提升中，许多模型都是按顺序训练的。每个新模型使用梯度下降法逐渐最小化整个系统的损失函数（y = ax + b + e，其中“e”是误差项）。学习方法连续拟合新模型，以更准确地估计响应变量。

该算法背后的主要思想是构造新的基学习器，它可以与损失函数的负梯度最佳相关，并与整个集成相关。

在 Python Sklearn 库中，我们使用梯度树提升或 GBRT，它是提升到任意可微损失函数的推广。它可用于回归和分类问题。

您可以使用以下代码来实现此目的 -

#用于分类 from sklearn.ensemble import GradientBoostingClassifier #用于回归 from sklearn.ensemble import GradientBoostingRegressor clf = GradientBoostingClassifier(n_estimators = 100,learning_rate = 1.0, max_depth = 1) clf.fit(X_train, y_train)

以下是上述代码中使用的术语 -

n_估计器 − 这些控制弱学习器的数量。

学习率 − 这控制了弱学习器在最终组合中的贡献。 Learning_rate 和 n_estimators 之间存在权衡。

最大深度 − 这是单个回归估计器的最大深度，它限制了树中的节点数量。该参数经过调整以获得最佳性能，最佳值取决于输入变量的相互作用。

可以调整损失函数以获得更好的性能。