机器学习:自动编码器
使用自动编码器将高维数据拟合到更密集的表示中
我通过维基百科找到了自动编码器最简单的定义，它将自己翻译为“一种学习数据低维编码的机器学习模型”。这是减少数据集维数的最聪明的方法之一，只需使用微分终止(Tensorflow，PyTorch 等)的功能。事实上，我们应该有一个特定的神经网络架构，以实现这一点。不过，在开始之前，我们先简单概述一下降维。
PCA 与自动编码器
PCA 和自动编码器都打算学习低维表示，从而通过低维表示减少原始维度的重构误差。但是，正如您可能知道的，PCA 将原始数据转换为一组较低的相互正交的维度。我们称之为到另一个空间的线性转换。问题来自于线性部分。信息损失可能会更高。与自动编码器相比，神经网络使用梯度下降来估计较低维度的隐藏层的最佳可能参数。
设计自动编码器
自动编码器采用数据流通过瓶颈的架构。这个瓶颈代表了较低的维度。自动编码器被期望学习这个较低的维度，从而最小化在输入和输出之间定义的误差分数。
让我们来看看一个简单的自动编码器(来自维基百科)。
自动编码器示意图
如你所见，我们有一个中间元素，它是一个狭窄的通道。训练的输入和输出通常是相同的，因为我们打算学习低维表示。
使用 Keras 构建自动编码器
我们通常的进口商品是:
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt # for plots
处理数据；以 MNIST 手写数据集为例。
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()x_train = x_train.astype('float32') / 255
x_test = x_test.astype('float32') / 255x_train = np.round(x_train, 0)
x_test = np.round(x_test, 0)x_train = x_train.reshape((len(x_train), np.prod(x_train.shape[1:])))
x_test = x_test.reshape((len(x_test), np.prod(x_test.shape[1:])))print(x_train.shape)
请注意，我们对数据进行了四舍五入。这是因为这个数据集是灰度的，我们只考虑严格的黑色像素和严格的白色像素。这有助于我们形成一个 二元交叉熵 作为损失函数。
让我们使用 Keras functional API 创建网络。
inputs = tf.keras.layers.Input(784)
encoded_1 = tf.keras.layers.Dense(128)(inputs)
encoded = tf.keras.layers.Dense(64, activation='relu')(encoded_1)
decoded_1 = tf.keras.layers.Dense(128)(encoded)
decoded = tf.keras.layers.Dense(784, activation='sigmoid')(decoded_1)auto_encoder = tf.keras.Model(inputs, decoded)
auto_encoder.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])auto_encoder.summary()
tf.keras.utils.plot_model(auto_encoder, show_shapes=True, to_file='autoenc.png', dpi=200)
注意，我使用了binary _ cross entropy，因为我们的数据是二进制格式(0 或 1)。完整的层集是自动编码器(编码和解码以给出相同的输出)。让我们看看我们的编码器。我们可以使用从 输入 到 编码 的层来构建它，如下所示。
自动编码器的可视化
encoder = tf.keras.Model(inputs, encoded)encoder.summary()
tf.keras.utils.plot_model(encoder, show_shapes=True, to_file='enc.png', dpi=200)
编码器的可视化
虽然您可以使用顺序 Keras API 来实现这一点，但我发现函数式 API 更优雅(只是个人意见，您可能会在以后的文章中看到原因)。
使用自动编码器
既然我们已经构建了我们的自动编码器，我们可以拟合我们的训练数据。
auto_encoder.fit(x_train, x_train,
epochs=10,
batch_size=256,
shuffle=True)
经过训练，我获得了 0.98510.9851 的准确度，这个准确度还不错！。因此，我们可以期待降维方面的良好表现。
让我们看看 MNIST 测试数据集的估计低维和重建图像。
predicted_2dim = encoder.predict(x_test)
predicted_original = auto_encoder.predict(x_test)
注意，对于解码后的值，我直接将原始数据提供给完整的自动编码器，后者在编码后直接进行重构。对于编码，我使用编码器组件。
看起来怎么样？
未经调整的输入数据如下所示:
原始字符
编码图像看起来像这样:
编码字符
重建看起来是这样的；
重构字符
注意事项
- 请注意，重建的图像看起来很模糊。这是因为我们的最后一层是由s 形 函数激活的。该函数返回范围 0 和 1 内的值。
- 我们使用 relu 激活函数，因为在中间层，当我们使用 sigmoid 函数时，值变小的几率更高。
- 当我们减小隐藏维数时，重建的精度降低。重建看起来像这样。它只有人物的可辨别的特征，而不是确切的人物。
使用二维重建
- 我们可以看到，在上面的图像 9 和 4 几乎是相似的。更多的信息丢失了。
- 我的字符绘图功能(可能会有用)
shown = {}
fig = plt.figure(figsize=(20, 10))
fig.subplots_adjust(hspace=1, wspace=0.1)
i = 0for data, y in zip(predicted_original, y_test):
if y not in shown and y==len(shown):
i += 1
ax = fig.add_subplot(1, 10, i)
ax.text(1, -1, str(y), fontsize=25, ha='center', c='g')
ax.imshow(np.array(data).reshape(28, 28), cmap='gray')shown[y] = True
if len(shown) == 10:
break
随意更改代码并运行。希望这篇文章有用。我将在以后的文章中介绍变型自动编码器！
干杯！
机器学习基础和古代哲学家
他们可能也不会明白
扎克·法默在 Unsplash 上的照片
苏格拉底从他的 Jupyter 笔记本上抬起头，给了你那个眼神——你现在已经习惯了。你已经花了足够多的时间在古代伟大的哲学家身边，知道你即将接受教育。又来了。
“你不懂机器学习是什么意思？”他苦笑着说。“这正是重点。我以前告诉过你，最好知道你什么都不知道*。”
你靠在椅子上，叹了口气。当女服务员拿走你的咖啡杯时，你对她微微一笑。“但是苏格拉底，”你开始。“我找到的所有在线资源要么充斥着行话，要么过于简单，让我看不出其中的任何一点。”
苏格拉底抿了一口他的第三杯南瓜香料拿铁，停顿了一会儿。最终，他把目光回到了笔记本电脑上，再次开始敲键盘。“要是有人能写一篇关于它的博客就好了。”
基础知识
机器学习是一个复杂的领域，但如果你能把一些基础知识藏在记忆库中，那么你会更容易理解一些更高级的资源和对话。今天，我们将讨论一些不可避免的概念。
什么是机器学习来着？
机器学习是“对计算机编程的科学(和艺术)，以便它们可以从数据中学习”(A. Géron 在他的 2019 年书中)。这是教计算机有用的东西。虽然人类的大脑极其复杂，但有很多任务电脑比我们做得更好。一个这样的任务是在非常大的数据集合中识别模式。如果你能给计算机足够多的例子来说明你想让它做什么，当你给它新的例子时，它就能学会如何自己做决定。
这很好吧？
是的，非常好！在某些任务上，计算机可以比人快几个数量级，而且往往也更准确。这项任务可以是图像识别——根据图像中的物体对图像进行标记或分类，或者检测医学扫描中的异常情况。它可能是转录或翻译讲话。它可以预测某个事件在未来发生的可能性，这通常需要多年的研究和对某个现象的专业知识。机器学习节省了时间和金钱，并且可以以其超人的性能更广泛地为企业和社会产生新的可能性。
监督学习
在监督学习中，你训练机器学习模型的数据带有你希望计算机预测的结果标签。例如，如果你想预测一名银行客户是否会拖欠新贷款，你可以向机器学习模型输入以前客户的数据，包括 他们是否最终违约，希望它学习如何识别高风险客户。通过这种方式，学习过程被“监督”,因为计算机被告知数据对应于哪个答案。
无监督学习
在无监督学习中，模型的训练数据不带有任何标签。然后，计算机被要求做几件事情中的一件——这可能是将数据分成相似实例的组，以识别异常值(与其他数据点完全不同的数据点——就像一个穿着长袍的灰胡子男人在其他正常的星巴克里一样)，或者突出输入变量之间的潜在关系。无人监督的学习可能被用来标记非典型的和看起来像欺诈的金融交易。或者它可以用来调查人们在网上商店购物时倾向于一起购买什么样的产品。
强化学习
强化学习是由一个“代理”定义的，它可以从几个动作或输出中进行选择。该代理在做出选择时会得到反馈，并因做出“好”的选择而获得奖励(根据我们预先指定的一些定义)。该代理最初的工作糟糕透顶，但随着它收集越来越多的行动反馈，它会很快变得更好。强化学习可以用来训练制造机器人——例如生产线上的机械臂。机器人手臂因执行所需的动作而获得奖励——无论是将组件从一个地方移动到另一个地方，还是建造某个汽车部件——并因不相关或负面的动作而受到惩罚(例如摔东西、制造混乱，或变得有自我意识并试图毁灭所有人类)。坏机器人)。
我听说的深度学习是怎么回事？
深度学习是机器学习的一个子领域，它涉及由所谓的“人工神经网络”组成的模型。这些是由分层算法组成的，可以在输入数据中逐步提取越来越复杂的特征。例如，人脸图像的低级和简单特征将是人脸的边缘所在的位置。一个更复杂的特征可能是这个人看起来是快乐还是悲伤——这并不简单。这些算法由一层层的“神经元”组成，这些神经元与人脑的神经元大致类似，因为给定一定的输入，模型中的一些神经元会激活，而另一些不会。神经元然后一起工作，共同决定模型应该输出什么。
深度学习系统可能极其复杂，但也可能极其强大。这些架构支撑了脸书的自动照片标记功能、谷歌翻译，甚至是可以在围棋等游戏中击败世界级选手的算法——仅在几年前，这还被认为是我们当前技术无法实现的壮举。
NLP 到底是什么？？？
自然语言处理，缩写为 NLP，是机器学习的另一个子领域，旨在设计能够理解人类语言及其背后意图的计算机模型。NLP 模型可以被设计和训练来简化或总结文档，分析书面文本的语气或情绪，识别和翻译语音，或者预测你想在手机键盘上打出的下一个单词。NLP 是一系列机器学习问题的统称，这些问题在本质上可能是有监督的，也可能是无监督的。
结论
这是对一些高级机器学习概念的快速介绍。它可能仍然让人觉得是一个难以理解的广阔研究领域——这是因为它确实如此！像许多其他学科一样，人们把他们的一生都奉献给了极其狭窄的研究领域，并且只找到了越来越多的深度去探索。
但希望下次你打开一篇关于机器学习最新发展的文章时，你能够认出这次的一些关键主题。然后，也许你可以选择一两个你不太理解的话题或术语，做一些研究，试图掌握它们。你可能会以问题多于答案而告终——但这不一定是件坏事。如果你能做到这一点，那么至少你会知道你所不知道的。
苏格拉底会感到骄傲的。
*当然，没有记录表明苏格拉底本人说过这句话。
或者他喜欢南瓜香料拿铁。
更多信息和积分
Andrew Hetherington 是英国伦敦的一名见习精算师和数据爱好者。
机器学习基础:决策树回归
实施决策树回归算法并绘制结果。
之前，我已经解释了各种回归模型，如线性、多项式和支持向量回归。在本文中，我将通过一个真实的例子向您介绍决策树回归的算法和实现。
决策树算法综述
决策树是监督学习最常用、最实用的方法之一。它既可以用来解决回归问题，也可以用来解决分类问题，而分类问题在实际应用中得到更多的应用。
它是一个树形结构的分类器，有三种类型的节点。 根节点 是代表整个样本的初始节点，并且可以被进一步分割成更多的节点。 内部节点 代表数据集的特征，分支代表决策规则。最后， 叶节点 表示结果。这个算法对于解决决策相关的问题非常有用。
对于一个特定的数据点，通过回答对/错问题来完全遍历整个树，直到它到达叶节点。最终预测是该特定叶节点中因变量的平均值。通过多次迭代，该树能够预测数据点的适当值。
决策树模型示例(来源
上图是决策树算法实现的示意图。决策树具有易于理解、需要较少的数据清理、非线性不影响模型性能以及要调整的超参数数量几乎为零的优点。然而，它可能有一个过度拟合的问题，这个问题可以使用 随机森林 算法来解决，这将在下一篇文章中解释。
在这个例子中，我们将经历 决策树回归 的实现，其中我们将根据一个地区 500 天的温度来预测一家冰淇淋店的收入。
问题分析
在这个数据中，我们有一个独立变量温度和一个独立变量收入，我们必须预测它们。在这个问题中，我们必须建立一个决策树回归模型，该模型将研究冰淇淋店的温度和收入之间的相关性，并根据特定日期的温度预测冰淇淋店的收入。
步骤 1:导入库
第一步总是包括导入开发 ML 模型所需的库。导入 NumPy ， matplotlib 和 熊猫库 。
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
步骤 2:导入数据集
在这一步中，我们将使用 pandas 来存储从我的 github 存储库中获得的数据，并使用函数’ pd.read_csv ‘将其存储为 Pandas DataFrame。在此，我们将自变量(X)分配给’*温度’*列，将因变量(y)分配给’*收入’*列。
dataset = pd.read_csv('[https://raw.githubusercontent.com/mk-gurucharan/Regression/master/IceCreamData.csv'](https://raw.githubusercontent.com/mk-gurucharan/Regression/master/IceCreamData.csv'))X = dataset['Temperature'].values
y = dataset['Revenue'].valuesdataset.head(5)>>Temperature Revenue
24.566884 534.799028
26.005191 625.190122
27.790554 660.632289
20.595335 487.706960
11.503498 316.240194
步骤 3:将数据集分为训练集和测试集
下一步，我们必须像往常一样将数据集分成训练集和测试集。为此，我们使用test_size=0.05,这意味着 500 个数据行的 5%(25 行)将仅用作测试集，剩余的 475 行将用作构建模型的训练集。
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.05)
步骤 4:在训练集上训练决策树回归模型
我们从sklearn.tree导入DecisionTreeRegressor类，并将其赋给变量’ ‘回归变量’ 。然后我们通过使用regressor.fit函数将 X_train 和 y_train 拟合到模型中。我们使用reshape(-1,1)将变量整形为一个列向量。
# Fitting Decision Tree Regression to the dataset
from sklearn.tree import DecisionTreeRegressor
regressor = DecisionTreeRegressor()
regressor.fit(X_train.reshape(-1,1), y_train.reshape(-1,1))
第五步:预测结果
在此步骤中，我们使用regressor.predict函数预测模型在训练集值上训练的测试集的结果，并将其分配给’ y_pred’ 。
y_pred = regressor.predict(X_test.reshape(-1,1))
步骤 6:将实际值与预测值进行比较
在这一步中，我们将在 Pandas 数据帧中比较并显示 y_test 的值为’真实值，y_pred 的值为’预测值。
df = pd.DataFrame({'Real Values':y_test.reshape(-1), 'Predicted Values':y_pred.reshape(-1)})
df>>
Real Values Predicted Values
448.325981 425.265596
535.866729 500.065779
264.123914 237.763911
691.855484 698.971806
587.221246 571.434257
653.986736 633.504009
538.179684 530.748225
643.944327 660.632289
771.789537 797.566536
644.488633 654.197406
192.341996 223.435016
491.430500 477.295054
781.983795 807.541287
432.819795 420.966453
623.598861 612.803770
599.364914 534.799028
856.303304 850.246982
583.084449 596.236690
521.775445 503.084268
228.901030 258.286810
453.785607 473.568112
406.516091 450.473207
562.792463 634.121978
642.349814 621.189730
737.800824 733.215828
从上述值，我们推断该模型能够以良好的准确度预测 y_test 的值。
步骤 7:可视化决策树回归结果
温度与收入(决策树回归)
在该图中，实际值用“ 、红色 ”绘制，预测值用“ 、绿色 ”绘制。决策树回归模型的绘图也是用 黑色 颜色绘制的。
我附上了我的 github 资源库的链接，你可以在那里找到 Google Colab 笔记本和数据文件供你参考。
GitHub 是超过 5000 万开发人员的家园，他们一起工作来托管和审查代码、管理项目和构建…
github.com](https://github.com/mk-gurucharan/Regression)
我真的希望我已经用一个例子解释了构建决策树回归模型的 ML 代码。
您还可以在下面找到该程序对其他回归模型的解释:
在接下来的文章中，我们将会遇到更复杂的回归、分类和聚类模型。到那时，快乐的机器学习！
机器学习基础:K-最近邻分类
了解 KNN 分类并在简单数据集上构建模型以可视化您的结果！
在之前的故事中，我已经解释了各种 回归 模型的实现程序。此外，我已经描述了逻辑回归模型的实现。在本文中，我们将看到 K-最近邻或 KNN 分类的算法以及一个简单的例子。
KNN 分类概述
K-最近邻或 KNN 分类是一种简单且易于实现的监督机器学习算法，主要用于分类问题。
让我们用一个非常简单的例子来理解这个算法。假设有两个类，分别用矩形和三角形表示。如果我们想给任何一个类添加一个新的形状(菱形),那么我们可以实现 KNN 分类模型。
KNN 模型(来源——自我)
在这个模型中，我们必须选择最近邻的数量(N)。这里，由于我们选择了 N=4，新的数据点将计算每个点之间的距离，并在其最近的 4 个邻居周围绘制一个圆形区域(N=4)。在这个问题中，由于所有四个最近的邻居都位于类 1(矩形)中，所以新的数据点(菱形)也被指定为类 1 数据点。
这样，我们可以用不同的值改变参数 N，并通过试错法为模型选择最精确的值，也避免了过拟合和高损失。
这样，我们就可以实现 KNN 分类算法。现在让我们在下一节中通过一个真实的例子来讨论它的实现。
问题分析
为了在实际应用中应用 KNN 分类模型，我使用了与构建逻辑回归模型相同的数据集。在这里，我们 DMV 测试数据集有三列。前两列由两个 DMV 书面测试( DMV_Test_1 和 DMV_Test_2 )组成，这两列是自变量，最后一列由因变量 Results 组成，这两列表示驾驶员已获得驾照(1)或未获得驾照(0)。
在这种情况下，我们必须使用这些数据建立一个 KNN 分类模型，以预测参加了两次 DMV 笔试的司机是否会获得驾照，并使用他们在笔试中获得的分数对结果进行分类。
步骤 1:导入库
和往常一样，第一步总是包括导入库，即 NumPy、Pandas 和 Matplotlib。
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
步骤 2:导入数据集
在这一步中，我们将从我的 GitHub 存储库中以“DMVWrittenTests.csv”的形式获取数据集。变量 X 将存储两个 DMV 测试 ，变量 Y 将最终输出存储为 结果***。***dataset.head(5)用于可视化前 5 行数据。
dataset = pd.read_csv('[https://raw.githubusercontent.com/mk-gurucharan/Classification/master/DMVWrittenTests.csv'](https://raw.githubusercontent.com/mk-gurucharan/Classification/master/DMVWrittenTests.csv'))X = dataset.iloc[:, [0, 1]].values
y = dataset.iloc[:, 2].valuesdataset.head(5)>>
DMV_Test_1 DMV_Test_2 Results
34.623660 78.024693 0
30.286711 43.894998 0
35.847409 72.902198 0
60.182599 86.308552 1
79.032736 75.344376 1
步骤 3:将数据集分为训练集和测试集
在这一步中，我们必须将数据集分为训练集和测试集，在训练集上将训练逻辑回归模型，在测试集上将应用训练模型对结果进行分类。其中的test_size=0.25表示*数据的 25%将作为 测试集 保存，剩余的 75%将作为 训练集 用于训练。*
**from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25)**
步骤 4:特征缩放
这是一个附加步骤，用于对特定范围内的数据进行标准化。它也有助于加速计算。由于数据变化很大，我们使用此函数将数据范围限制在一个小范围内(-2，2)。例如，分数 62.0730638 被规范化为-0.21231162，分数 96.51142588 被规范化为 1.55187648。这样 X_train 和 X_test 的分数就归一化到一个更小的范围。
**from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)**
步骤 5:在训练集上训练 KNN 分类模型
在这一步中，类KNeighborsClassifier被导入并分配给变量 【分类器】 。classifier.fit()功能配有 X_train 和 Y_train 对模型进行训练。
**from sklearn.neighbors import KNeighborsClassifier
classifier = KNeighborsClassifier(n_neighbors = 5, metric = 'minkowski', p = 2)
classifier.fit(X_train, y_train)**
步骤 6:预测测试集结果
在这一步中，classifier.predict()函数用于预测测试集的值，这些值被存储到变量y_pred.
**y_pred = classifier.predict(X_test)
y_pred**
步骤 7:混淆矩阵和准确性
这是分类技术中最常用的一步。在这里，我们看到了训练模型的准确性，并绘制了混淆矩阵。
混淆矩阵是一个表，用于显示当测试集的真实值已知时，对分类问题的正确和错误预测的数量。它的格式如下
来源—自己
真实值是正确预测的次数。
**from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)from sklearn.metrics import accuracy_score
print ("Accuracy : ", accuracy_score(y_test, y_pred))
cm>>Accuracy : 0.92>>array([[11, 1],
[ 1, 12]])**
从上面的混淆矩阵，我们推断，在 25 个测试集数据中，23 个被正确分类，2 个被错误分类，这比逻辑回归模型好不了多少。
步骤 8:将实际值与预测值进行比较
在这个步骤中，创建一个 Pandas DataFrame 来比较原始测试集( y_test )和预测结果( y_pred )的分类值。
**df = pd.DataFrame({'Real Values':y_test, 'Predicted Values':y_pred})
df>>
Real Values Predicted Values
0 0
0 1
1 1
0 0
0 0
1 1
1 1
0 0
0 0
1 1
0 0
1 0
1 1
1 1
0 0
0 0
0 0
1 1
1 1
1 1
1 1
0 0
1 1
1 1
0 0**
虽然这种可视化可能没有回归那么有用，但从这一点上，我们可以看到，该模型能够以 92%的相当高的准确度对测试集值进行分类，如上面计算的那样。
步骤 9:可视化结果
在最后一步中，我们将 KNN 分类模型的结果可视化在一个沿着两个区域绘制的图上。
**from matplotlib.colors import ListedColormap
X_set, y_set = X_test, y_test
X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() - 1, stop = X_set[:, 0].max() + 1, step = 0.01),
np.arange(start = X_set[:, 1].min() - 1, stop = X_set[:, 1].max() + 1, step = 0.01))
plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),
alpha = 0.75, cmap = ListedColormap(('red', 'green')))
plt.xlim(X1.min(), X1.max())
plt.ylim(X2.min(), X2.max())
for i, j in enumerate(np.unique(y_set)):
plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1],
c = ListedColormap(('red', 'green'))(i), label = j)
plt.title('KNN Classification')
plt.xlabel('DMV_Test_1')
plt.ylabel('DMV_Test_2')
plt.legend()
plt.show()**
KNN 分类
在该图中，值 1(即，是) 用“红色绘制，值 0(即，否) 用“绿色绘制。KNN 分类模型将这两个区域分开。它不像逻辑回归模型那样是线性的。因此，具有给定的两个数据点(DMV_Test_1 和 DMV_Test_2)的任何数据都可以绘制在图上，并且根据属于哪个区域，结果(获得驾驶执照)可以分类为是或否。
根据上面的计算，我们可以看到测试集中有两个值，每个区域都有一个被错误分类的值。
结论—
因此，在这个故事中，我们已经成功地建立了一个 KNN 分类 模型，它能够预测一个人是否能够通过笔试获得驾驶执照，并可视化结果。
我还附上了我的 GitHub 资源库的链接，你可以在那里下载这个 Google Colab 笔记本和数据文件供你参考。
这是一个由 Python 代码组成的知识库，用于构建不同类型的分类模型，以评估和…
github.com](https://github.com/mk-gurucharan/Classification)
您还可以在下面找到该程序对其他分类模型的解释:
- 逻辑回归
- k 近邻(KNN)分类
- 支持向量机(SVM)分类(即将推出)
- 朴素贝叶斯分类(即将推出)
- 随机森林分类(即将推出)
在接下来的文章中，我们将会遇到更复杂的回归、分类和聚类模型。到那时，快乐的机器学习！**
机器学习基础:逻辑回归
学习逻辑回归基本分类模型的算法及其实现
在之前的故事中，我已经解释了各种 回归 模型的实现程序。当我们继续讨论 分类 时，为什么这个算法的名称仍然是回归，这难道不令人惊讶吗？让我们了解逻辑回归的机制，并通过一个例子学习建立分类模型。
逻辑回归概述
逻辑回归是一种分类模型，在因变量(输出)为二进制格式时使用，如 0(假)或 1(真)。例子包括例如预测是否有肿瘤(1)或没有肿瘤(0)以及电子邮件是否是垃圾邮件(1)或没有垃圾邮件(0)。
逻辑函数，也称为 sigmoid 函数，最初由统计学家用来描述生态学中人口增长的特性。sigmoid 函数是一种数学函数，用于将预测值映射到概率。逻辑回归有一个 S 形曲线，可以取 0 到 1 之间的值，但永远不会精确到这些极限。它有1 / (1 + e^-value)的公式。
Sigmoid 函数(来源)
逻辑回归是线性回归模型的扩展。让我们用一个简单的例子来理解这一点。如果我们想要分类一封电子邮件是否是垃圾邮件，如果我们应用线性回归模型，我们将只得到 0 和 1 之间的连续值，如 0.4、0.7 等。另一方面，逻辑回归通过将阈值设置为 0.5 来扩展该线性回归模型，因此如果输出值大于 0.5，则数据点将被分类为垃圾邮件，如果输出值小于 0.5，则不是垃圾邮件。
这样就可以用逻辑回归对问题进行分类，得到准确的预测。
问题分析
为了在实际使用中应用逻辑回归模型，让我们考虑由三列组成的 DMV 测试数据集。前两列由两个 DMV 书面测试( DMV_Test_1 和 DMV_Test_2 )组成，这两个测试是自变量，最后一列由因变量 结果 组成，这两个结果表示驾驶员已获得驾照(1)或未获得驾照(0)。
在这种情况下，我们必须使用这些数据建立一个逻辑回归模型，以预测参加了两次 DMV 笔试的司机是否会获得驾照，并使用他们在笔试中获得的分数对结果进行分类。
步骤 1:导入库
和往常一样，第一步总是包括导入库，即 NumPy、Pandas 和 Matplotlib。
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
步骤 2:导入数据集
在这一步中，我们将从我的 GitHub 存储库中以“DMVWrittenTests.csv”的形式获取数据集。变量 X 将存储两个 DMV 测试 ，变量 Y 将最终输出存储为 结果***。***dataset.head(5)用于可视化前 5 行数据。
dataset = pd.read_csv('[https://raw.githubusercontent.com/mk-gurucharan/Classification/master/DMVWrittenTests.csv'](https://raw.githubusercontent.com/mk-gurucharan/Classification/master/DMVWrittenTests.csv'))X = dataset.iloc[:, [0, 1]].values
y = dataset.iloc[:, 2].valuesdataset.head(5)>>
DMV_Test_1 DMV_Test_2 Results
34.623660 78.024693 0
30.286711 43.894998 0
35.847409 72.902198 0
60.182599 86.308552 1
79.032736 75.344376 1
步骤 3:将数据集分为训练集和测试集
在这一步中，我们必须将数据集分为训练集和测试集，在训练集上将训练逻辑回归模型，在测试集上将应用训练模型对结果进行分类。其中的test_size=0.25表示*数据的 25%将作为 测试集 保存，剩余的 75%将作为 训练集 用于训练。*
**from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)**
步骤 4:特征缩放
这是一个附加步骤，用于对特定范围内的数据进行标准化。它也有助于加速计算。由于数据变化很大，我们使用此函数将数据范围限制在一个小范围内(-2，2)。例如，分数 62.0730638 被规范化为-0.21231162，分数 96.51142588 被规范化为 1.55187648。这样 X_train 和 X_test 的分数就归一化到一个更小的范围。
**from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)**
步骤 5:在训练集上训练逻辑回归模型
在这一步中，类LogisticRegression被导入并分配给变量 【分类器】 。classifier.fit()功能配有 X_train 和 Y_train 对模型进行训练。
**from sklearn.linear_model import LogisticRegression
classifier = LogisticRegression()
classifier.fit(X_train, y_train)**
步骤 6:预测测试集结果
在这一步中，classifier.predict()函数用于预测测试集的值，这些值被存储到变量y_pred.
**y_pred = classifier.predict(X_test)
y_pred**
步骤 7:混淆矩阵和准确性
这是分类技术中最常用的一步。在这里，我们看到了训练模型的准确性，并绘制了混淆矩阵。
混淆矩阵是一个表，用于显示当测试集的真实值已知时，对分类问题的正确和错误预测的数量。它的格式如下
来源—自己
真实值是正确预测的次数。
**from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)from sklearn.metrics import accuracy_score
print ("Accuracy : ", accuracy_score(y_test, y_pred))
cm>>Accuracy : 0.88
>>array([[11, 0],
[ 3, 11]])**
从上面的混淆矩阵，我们推断，在 25 个测试集数据中，22 个被正确分类，3 个被错误分类。很好的开始，不是吗？
步骤 8:将实际值与预测值进行比较
在这个步骤中，创建一个 Pandas DataFrame 来比较原始测试集( y_test )和预测结果( y_pred )的分类值。
**df = pd.DataFrame({'Real Values':y_test, 'Predicted Values':y_pred})
df>>
Real Values Predicted Values
1 1
0 0
0 0
0 0
1 1
1 1
1 0
1 1
0 0
1 1
0 0
0 0
0 0
1 1
1 0
1 1
0 0
1 1
1 0
1 1
0 0
0 0
1 1
1 1
0 0**
虽然这种可视化可能没有回归那么有用，但从这一点上，我们可以看到，该模型能够以 88%的正确率对测试集值进行分类，如上所述。
步骤 9:可视化结果
在最后一步中，我们将逻辑回归模型的结果可视化在一个图表上，该图表与两个区域一起绘制。
**from matplotlib.colors import ListedColormap
X_set, y_set = X_test, y_test
X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() - 1, stop = X_set[:, 0].max() + 1, step = 0.01),
np.arange(start = X_set[:, 1].min() - 1, stop = X_set[:, 1].max() + 1, step = 0.01))
plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),
alpha = 0.75, cmap = ListedColormap(('red', 'green')))
plt.xlim(X1.min(), X1.max())
plt.ylim(X2.min(), X2.max())
for i, j in enumerate(np.unique(y_set)):
plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1],
c = ListedColormap(('red', 'green'))(i), label = j)
plt.title('Logistic Regression')
plt.xlabel('DMV_Test_1')
plt.ylabel('DMV_Test_2')
plt.legend()
plt.show()**
逻辑回归
在该图中，值 1(即，是) 以“红色绘制，值 0(即，否) 以“绿色绘制。逻辑回归线将这两个区域分开。因此，具有给定的两个数据点(DMV_Test_1 和 DMV_Test_2)的任何数据都可以绘制在图上，并且根据属于哪个区域，结果(获得驾驶执照)可以分类为是或否。
根据上面的计算，我们可以看到测试集中有三个值被错误地归类为“否”,因为它们位于线的另一端。
逻辑回归
结论—
因此，在这个故事中，我们已经成功地建立了一个 逻辑回归 模型，该模型能够预测一个人是否能够通过笔试获得驾驶执照，并可视化结果。
我还附上了我的 GitHub 资源库的链接，你可以在那里下载这个 Google Colab 笔记本和数据文件供你参考。
这是一个由 Python 代码组成的知识库，用于构建不同类型的分类模型，以评估和…
github.com](https://github.com/mk-gurucharan/Classification)
您还可以在下面找到该程序对其他分类模型的解释:
- 逻辑回归
- k-最近邻(KNN)分类(即将推出)
- 支持向量机(SVM)分类(即将推出)
- 朴素贝叶斯分类(即将推出)
- 随机森林分类(即将推出)
在接下来的文章中，我们将会遇到更复杂的回归、分类和聚类模型。到那时，快乐的机器学习！**
机器学习基础:多元线性回归
学习用 Python 编程实现多元线性回归。
在前面的故事中，我简要介绍了线性回归，并展示了如何执行简单的线性回归。在简单线性回归中，我们有一个因变量(y)和一个自变量(x)。如果学生的分数取决于两个或更多的独立变量会怎样？
概观
在这个例子中，我们将经历 多元线性回归 的实现，其中我们将为一个想要分析一个初创公司是否值得投资以获得良好回报的风险投资家预测初创公司的利润。
线性回归(来源)
问题分析
在这个数据中，我们有四个自变量，即， R & D 支出，行政管理，营销支出和状态。有一个自变量，即利润。因此，我们的工作是用这些数据训练 ML 模型，以了解四个特征(或独立变量)之间的相关性，并使用所有这些数据预测另一家新公司的利润。
步骤 1:导入库
在第一步中，我们将导入构建 ML 模型所需的库。导入 NumPy 库和 matplotlib 。另外，我们导入了 熊猫 库进行数据分析。
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
步骤 2:导入数据集
在下一步中，我们将使用 pandas 来存储从我的 github 存储库中获得的数据，并使用函数" pd.read_csv “将其存储为名为” dataset "的 Pandas DataFrame。
我们浏览我们的数据集，并将自变量(x)分配给数据集的前四列，即 R&D 支出(指数=0)、行政管理(指数=1)、营销支出(指数=2)和州(指数=3)。
dataset = pd.read_csv('[https://raw.githubusercontent.com/mk-gurucharan/Regression/master/Startups_Data.csv'](https://raw.githubusercontent.com/mk-gurucharan/Regression/master/Startups_Data.csv'))X = dataset.iloc[:, :-1].values
y = dataset.iloc[:, -1].valuesdataset.head(5)>>
R&D Spend Administration Marketing Spend State Profit
165349.20 136897.80 471784.10 New York 192261.83
162597.70 151377.59 443898.53 California 191792.06
153441.51 101145.55 407934.54 Florida 191050.39
144372.41 118671.85 383199.62 New York 182901.99
142107.34 91391.77 366168.42 Florida 166187.94
我们使用相应的。iloc 函数对数据帧进行切片，将这些索引赋给 x，这里我们使用 [:，:-1] ，可以解释为**【包含所有行，包含所有列直到-1(不含-1)】**。在这里，-1 表示倒数第一列。因此，我们将第 0、1、2 和 3 列指定为 x。
我们将最后一列(-1)分配给因变量 y。我们打印数据帧以查看我们是否为训练数据获得了正确的列。
步骤 3:编码分类数据
只要数据集中有数字，我们就可以轻松地对数据集进行数学计算，并创建预测模型。在这个数据集中，我们遇到了一个非数字变量，即“ 、状态 ”。这也称为分类数据。
我们使用另一个叫做 **sklearn 的重要库对这些分类数据进行编码。**在这里，我们导入了 ColumnTransformer 和 OneHotEncoder 。ColumnTransformer 允许单独转换数据帧的特定列。在我们的例子中，我们使用 OneHotEncoder 将“State”列(index=3)转换为数字数据。
在对分类数据进行编码后，我们打印数据帧 X 并查看变化。我们看到在开始时增加了三个新栏目。每一列代表一个“状态”。例如，在第一行中，第三列表示“纽约”，因此第三列中的值为“1”。
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(), [3])], remainder='passthrough')
X = np.array(ct.fit_transform(X))
步骤 4:将数据集分为训练集和测试集
一旦我们准备好了数据集，下一个重要的任务就是将数据集分成训练集和测试集。我们这样做是为了用称为“训练集的一部分数据训练我们的模型，并在称为“测试集的另一组数据上测试预测结果。
我们使用“train_test_split”函数来拆分我们的数据。这里我们给出“test_size =0.2”，表示 20%的数据是测试集。在我们的例子中，将选择 10 个随机启动数据作为测试集，并将选择 40 个剩余的启动数据作为训练集。
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2)
步骤 5:在训练集上训练多元线性回归模型
下一步，我们导入" LinearRegression "类，它将应用于我们的训练集。我们给 LinearRegression 类分配一个变量“回归变量”。然后，我们使用“ regressor.fit ”将训练数据集(X_train 和 y_train)拟合到这个线性回归类，以便进行训练过程。
from sklearn.linear_model import LinearRegression
regressor = LinearRegression()
regressor.fit(X_train, y_train)
步骤 6:预测测试集结果
下一步，我们将使用训练好的模型(即“回归器”)来预测测试集的利润。测试集数据(X_test)的真实值(利润)存储在变量 y_test 中。
然后，我们使用“ regressor.predict ”函数来预测测试数据 X_test 的值。我们将预测值指定为 y_pred。我们现在有两个数据，y_test(真实值)和 y_pred(预测值)。
y_pred = regressor.predict(X_test)
步骤 7:将测试集与预测值进行比较
在这一步中，我们将把 y_test 的值打印为 Pandas DataFrame 中每个 X_test 的实际值和 y_pred 值打印为 预测值 。这样，我们获得了所有 10 个 X_test 数据的值。
*df = pd.DataFrame({'Real Values':y_test, 'Predicted Values':y_pred})
df>>
Real Values Predicted Values
78239.91 74963.602167
182901.99 173144.548525
64926.08 45804.248438
105733.54 108530.843936
141585.52 127674.466487
108552.04 111471.421444
146121.95 133618.038644
105008.31 114655.651664
96778.92 96466.443219
97483.56 96007.236281*
在第一行中，实际值的值为 78239.91 ，预测值的值为 74963.60 。我们看到该模型已经精确地预测了该值，因此我们可以说我们的模型具有良好的准确性。
恭喜你！现在，您已经从构建简单的线性回归模型扩展到多元线性回归模型。我附上了我的 Github 资源库的链接，你可以在那里找到 Python 笔记本和数据文件供你参考。
GitHub 是超过 5000 万开发人员的家园，他们一起工作来托管和审查代码、管理项目和构建…
github.com](https://github.com/mk-gurucharan/Regression)
希望我已经清楚地解释了开发多元线性回归的 ML 模型的过程，以便用相关数据预测一家初创公司的利润。
您还可以在下面找到该程序对其他回归模型的解释:
在接下来的文章中，我们将会遇到更复杂的回归、分类和聚类模型。到那时，快乐的机器学习！*
机器学习基础:朴素贝叶斯分类
了解朴素贝叶斯算法，并通过实现朴素贝叶斯分类模型来解决一个著名的虹膜数据集问题
在之前的故事中，我已经解释了各种 回归 模型的实现程序。此外，我还描述了逻辑回归，KNN 和 SVM 分类模型的实施。在本文中，我们将通过一个例子来介绍著名的朴素贝叶斯分类模型的算法。
朴素贝叶斯分类综述
朴素贝叶斯就是这样一种分类算法，由于其“”的特性，在分类中是一个不容忽视的算法。它假设测量的特征是相互独立的。
例如，如果一种动物有猫眼、胡须和一条长尾巴，它就可以被认为是猫。即使这些特征相互依赖或依赖于其他特征的存在，所有这些特性独立地促成了这种动物是猫的可能性，这就是为什么它被称为“天真”。
根据贝叶斯定理，各种特征是相互独立的。对于两个独立的事件，P(A,B) = P(A)P(B)。贝叶斯定理的这个假设可能在实践中从未遇到过，因此它解释了朴素贝叶斯中的“朴素”部分。贝叶斯定理表述为:P(a | b)=(P(b | a) P(a))/P(b)。 其中 P(a|b)是给定 b 的概率。*
让我们用一个简单的例子来理解这个算法。如果这个学生在考试那天穿红色的衣服，他就会通过考试。我们可以使用上面讨论的后验概率方法来解决它。
由贝叶斯定理， P(通|红)= P(红|通) P(通)/ P(红)。*
从数值来看，我们假设 P(红|通)= 3/9 = 0.33，P(红)= 5/14 = 0.36，P(通)= 9/14 = 0.64。现在 P(通|红)= 0.33 * 0.64 / 0.36 = 0.60，概率较高。
这样，朴素贝叶斯使用类似的方法来预测基于各种属性的不同类的概率。
问题分析
为了实现朴素贝叶斯分类，我们将使用一个非常著名的鸢尾花数据集，它由 3 类花组成。其中有 4 个自变量，分别是:萼片宽度花瓣长度** 和 花瓣宽度 。因变量是 物种 ，我们将利用花的四个独立特征对其进行预测。**
安妮·斯普拉特在 Unsplash 上的照片
有 3 类物种，即刚毛藻、云芝和海滨锦葵。这个数据集最初是由罗纳德·费雪在 1936 年提出的。使用花的各种特征(独立变量)，我们必须使用朴素贝叶斯分类模型对给定的花进行分类。
步骤 1:导入库
和往常一样，第一步总是包括导入库，即 NumPy、Pandas 和 Matplotlib。
**import numpy as np
import matplotlib.pyplot as plt
import pandas as pd**
步骤 2:导入数据集
在这一步中，我们将导入 Iris Flower 数据集，该数据集作为IrisDataset.csv存储在我的 github 存储库中，并将其保存到变量dataset. 中。此后，我们将 4 个自变量分配给X，将因变量“物种”分配给 Y 。显示数据集的前 5 行。
**dataset = pd.read_csv('[https://raw.githubusercontent.com/mk-gurucharan/Classification/master/IrisDataset.csv'](https://raw.githubusercontent.com/mk-gurucharan/Classification/master/IrisDataset.csv'))X = dataset.iloc[:,:4].values
y = dataset['species'].valuesdataset.head(5)>>
sepal_length sepal_width petal_length petal_width species
5.1 3.5 1.4 0.2 setosa
4.9 3.0 1.4 0.2 setosa
4.7 3.2 1.3 0.2 setosa
4.6 3.1 1.5 0.2 setosa
5.0 3.6 1.4 0.2 setosa**
步骤 3:将数据集分为训练集和测试集
一旦我们获得了数据集，我们必须将数据分成训练集和测试集。在这个数据集中，有 150 行，3 个类中的每一个都有 50 行。由于每个类都是以连续的顺序给出的，所以我们需要随机分割数据集。这里，我们有test_size=0.2，这意味着数据集的的 20%将用于测试目的，剩余的的 80%将用于训练朴素贝叶斯分类模型。**
***from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2)***
步骤 4:特征缩放
使用要素缩放选项将数据集缩小到更小的范围。在这种情况下，X_train和X_test 值都被缩小到更小的值，以提高程序的速度。
***from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)***
步骤 5:在训练集上训练朴素贝叶斯分类模型
在这一步，我们引入从sklearn.naive_bayes库中使用的类GaussianNB。这里，我们使用了高斯模型，还有其他几种模型，如伯努利模型、分类模型和多项式模型。这里，我们将 GaussianNB 类分配给变量classifier，并为其拟合 X_train 和 y_train 值，用于训练目的。
***from sklearn.naive_bayes import GaussianNB
classifier = GaussianNB()
classifier.fit(X_train, y_train)***
步骤 6:预测测试集结果
一旦模型被训练，我们使用classifier.predict()来预测测试集的值，并且预测的值被存储到变量y_pred.
***y_pred = classifier.predict(X_test)
y_pred***
步骤 7:混淆矩阵和准确性
这是分类技术中最常用的一步。在这里，我们看到了训练模型的准确性，并绘制了混淆矩阵。
混淆矩阵是一个表，用于显示当测试集的真实值已知时，对分类问题的正确和错误预测的数量。它的格式如下
作者图片
真实值是正确预测的次数。
***from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)from sklearn.metrics import accuracy_score
print ("Accuracy : ", accuracy_score(y_test, y_pred))
cm>>Accuracy : 0.9666666666666667>>array([[14, 0, 0],
[ 0, 7, 0],
[ 0, 1, 8]])***
从上面的混淆矩阵，我们推断，在 30 个测试集数据中，29 个被正确分类，只有 1 个被错误分类。这给了我们 96.67%的高准确率。
步骤 8:将实际值与预测值进行比较
在这个步骤中，创建一个 Pandas DataFrame 来比较原始测试集( y_test )和预测结果( y_pred )的分类值。
**df = pd.DataFrame({'Real Values':y_test, 'Predicted Values':y_pred})
df>>
Real Values Predicted Values
setosa setosa
setosa setosa
virginica virginica
versicolor versicolor
setosa setosa
setosa setosa
... ... ... ... ...
virginica versicolor
virginica virginica
setosa setosa
setosa setosa
versicolor versicolor
versicolor versicolor**
这个步骤是一个额外的步骤，它不像混淆矩阵那样提供很多信息，并且主要用于回归以检查预测值的准确性。
如你所见，有一个错误的预测是预测了云芝而不是弗吉尼亚。
结论—
因此，在这个故事中，我们已经成功地建立了一个 朴素贝叶斯分类 模型，该模型能够根据 4 个特征对一朵花进行分类。这个模型可以用网上的其他几个分类数据集来实现和测试。
我还附上了我的 GitHub 资源库的链接，你可以在那里下载这个 Google Colab 笔记本和数据文件供你参考。
这是一个由 Python 代码组成的知识库，用于构建不同类型的分类模型，以评估和…
github.com](https://github.com/mk-gurucharan/Classification)
您还可以在下面找到该程序对其他分类模型的解释:
- 逻辑回归
- K-最近邻(KNN)分类
- 支持向量机(SVM)分类
- 朴素贝叶斯分类
- 随机森林分类(即将推出)
在接下来的文章中，我们将会遇到更复杂的回归、分类和聚类模型。到那时，快乐的机器学习！**
机器学习基础:多项式回归
了解如何构建多项式回归模型来预测非线性数据集的值。
在以前的故事中，我简要介绍了线性回归，并展示了如何执行简单和多元线性回归。在本文中，我们将通过程序来建立一个基于非线性数据的多项式回归模型。
概观
在前面的线性回归示例中，当数据绘制在图表上时，因变量和自变量之间存在线性关系。因此，更适合建立线性模型来获得准确的预测。如果数据点具有以下非线性，使得线性模型由于非线性而在预测中产生错误，会怎么样？
非线性数据点(来源
在这种情况下，我们必须建立一个多项式关系，它将精确地拟合给定图中的数据点。这被称为多项式回归。多项式回归曲线的公式如y=w1x+w2x²+..+b所示
以下是对非线性数据拟合线性回归模型和多项式回归模型的 gif。
左:线性回归，右:多项式回归(来源
正如我们所看到的，线性回归总是会出错，无论它如何努力去适应数据。另一方面，多项式回归图能够更准确地将数据点拟合到直线上。
在本例中，我们将完成 多项式回归 的实现，其中我们将根据新员工在以前公司的职位级别，从新公司相同职位级别的工资数据中预测其工资。
问题分析
在该数据中，我们有两个独立变量，即位置和水平。有一个自变量，即工资。因此，在这个问题中，我们必须使用该数据训练一个多项式回归模型，以了解公司中员工数据的级别和工资之间的相关性，并能够根据该数据预测新员工的工资。
步骤 1:导入库
在第一步中，我们将导入构建 ML 模型所需的库。导入 NumPy 库和 matplotlib 。另外，我们导入了 熊猫 库进行数据分析。
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
步骤 2:导入数据集
在这一步中，我们将使用 pandas 来存储从我的 github 存储库中获得的数据，并使用函数" pd.read_csv "将其存储为 Pandas DataFrame。
我们遍历数据集，将自变量(x)赋给列名为“”的第二列，将因变量(y)赋给最后一列，即要预测的“”工资。**
**dataset = pd.read_csv('[https://raw.githubusercontent.com/mk-gurucharan/Regression/master/PositionSalaries_Data.csv'](https://raw.githubusercontent.com/mk-gurucharan/Regression/master/PositionSalaries_Data.csv'))X = dataset.iloc[:, 1:-1].values
y = dataset.iloc[:, -1].valuesdataset.head(5)>>
Position Level Salary
Business Analyst 1 45000
Junior Consultant 2 50000
Senior Consultant 3 60000
Manager 4 80000
Country Manager 5 110000**
我们使用相应的。iloc 函数对数据帧进行切片，以将这些指数分配给 X 和 y。在这种情况下，级别被视为独立变量，并被分配给 X。要预测的因变量是最后一列(-1)，即薪金，它被分配给 y。我们打印 DataFrame " 数据集，以查看我们是否为训练数据获得了正确的列。
步骤 3:在整个数据集上训练多项式回归模型
我们使用的数据集只有很少的行数，因此我们训练整个数据集来构建多项式回归模型。在此" 多项式特性 "功能用于指定我们将要绘制的多项式线的次数。在此，度数被设定为 4 。
独立变量 X 随后被多项式特征类拟合，并被转换为新变量 X_poly 。在这种情况下，变量 X 被转换成新的矩阵 X_Poly，该矩阵包括所有次数=4 的特征的多项式组合。
**from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
poly_reg = PolynomialFeatures(degree = 4)
X_poly = poly_reg.fit_transform(X)
lin_reg = LinearRegression()
lin_reg.fit(X_poly, y)**
类"【linear regression】也被导入并赋给变量【Lin _ reg】，该变量与 X_poly 和 y 相匹配，用于构建模型。
第四步:预测结果
在这一步中，我们将根据构建的多项式回归模型来预测值 Salary。“ regressor.predict ”函数用于预测自变量 X_poly 的值。我们将预测值指定为 y_pred。我们现在有两个数据，y(真实值)和 y_pred(预测值)。
**y_pred = lin_reg.predict(X_poly)**
步骤 5:将实际值与预测值进行比较
在这一步中，我们将把 y 值打印为 Pandas DataFrame 中每个 X_test 的 实际值 和 y_pred 值作为 预测值 。
**df = pd.DataFrame({'Real Values':y, 'Predicted Values':y_pred})
df>>
Real Values Predicted Values
45000 53356.643357
50000 31759.906760
60000 58642.191142
80000 94632.867133
110000 121724.941725
150000 143275.058275
200000 184003.496504
300000 289994.172494
500000 528694.638695
1000000 988916.083916**
我们可以看到，该模型在拟合数据和根据职位级别预测员工工资方面做得非常好。
步骤 6: 可视化多项式回归结果
在最后一步中，我们将可视化使用给定数据构建的多项式模型，并在图上绘制“【y**”和“ y_pred ”的值，并分析结果**
**X_grid = np.arange(min(X), max(X), 0.1)
X_grid = X_grid.reshape((len(X_grid), 1))
plt.scatter(X, y, color = 'red')
plt.scatter(X, y_pred, color = 'green')
plt.plot(X_grid, lin_reg.predict(poly_reg.fit_transform(X_grid)), color = 'black')
plt.title('Polynomial Regression')
plt.xlabel('Position level')
plt.ylabel('Salary')
plt.show()**
多项式回归模型
在该图中，实际值用“ 红色 绘制，预测值用“ 绿色 绘制。生成的多项式回归线以“ 黑色 ”颜色绘制。
我附上了我的 github 资源库的链接，你可以在那里找到 Google Colab 笔记本和数据文件供你参考。
GitHub 是超过 5000 万开发人员的家园，他们一起工作来托管和审查代码、管理项目和构建…
github.com](https://github.com/mk-gurucharan/Regression)
希望我已经能够清楚地解释建立多项式回归模型的程序。
您还可以在下面找到该程序对其他回归模型的解释:
在接下来的文章中，我们将会遇到更复杂的回归、分类和聚类模型。到那时，快乐的机器学习！**
机器学习基础:随机森林分类
对数据集执行随机森林算法并可视化结果！
随机森林分类综述
随机森林也是一种基于“树”的算法，它使用多个决策树的质量特征来做出决策。因此，它可以被称为一个*‘森林’的树木，因此得名“随机森林”。术语“随机是因为这个算法是一个**‘随机生成的决策树’***的森林。
随机森林算法是对现有决策树算法的改进，现有决策树算法存在一个主要问题*“过拟合”*。与决策树算法相比，它被认为更快更准确。
随机森林算法(来源)
它结合了多个决策树的结果，并根据结果对输出进行分类。让我们用这个算法实际求解一个数据集。
问题分析
在这个随机森林分类模型的实现中，我们将使用一个社交网络广告数据集，我已经在构建 SVM 分类器时使用过它。它由三列组成。前两列是自变量，即’ 【年龄】’ 和’ 【估计销量】 ，最后一列是因变量’ 【购买量】’ ，以二进制格式表示个人是否购买了产品(1)或(0)。
使用这些数据，我们必须为一家产品公司建立一个分类器，该分类器将对特定年龄和特定薪水的人是否会购买他们在社交媒体平台上做广告的产品进行分类。
步骤 1:导入库
和往常一样，第一步总是包括导入库，即 NumPy、Pandas 和 Matplotlib。
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
步骤 2:导入数据集
在这一步中，我们将从我的 github 存储库中获取存储为SocialNetworkAds.csv 的数据集，并将其存储到变量 dataset 中。然后我们将相应的变量赋给 X 和 y。最后，我们将看到数据集的前 5 行。
dataset = pd.read_csv('[https://raw.githubusercontent.com/mk-gurucharan/Classification/master/SocialNetworkAds.csv'](https://raw.githubusercontent.com/mk-gurucharan/Classification/master/SocialNetworkAds.csv'))X = dataset.iloc[:, [0, 1]].values
y = dataset.iloc[:, 2].valuesdataset.head(5)>>
Age EstimatedSalary Purchased
19 19000 0
35 20000 0
26 43000 0
27 57000 0
19 76000 0
步骤 3:将数据集分为训练集和测试集
我们将把数据分成训练集和测试集。在此，我们保留了test_size=0.20。表示 数据的 20% 将作为 测试集 保留，剩余的80%训练集 用于训练。由于有 400 行，大约 80 个数据点将被分配给测试集，剩余的 320 个数据点将用于训练目的。
*from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2)*
步骤 4:特征缩放
这是一个额外的步骤，当我们把 X 的值缩小到一个更小的范围时，它将提高程序的速度。在这里，我们将X_train和X_test缩小到-2 到+2 的小范围。例如，工资 75000 按比例缩减为 0.16418997。
*from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)*
步骤 5:在训练集上训练随机森林分类模型
一旦训练测试准备好了，我们就可以导入RandomForestClassifier 类并使训练集适合我们的模型。类别SVC被分配给变量分类器。这里用的判据是“”。也可以使用的另一个标准是" 基尼 "。然后使用classifier.fit() 函数来训练模型。**
**from sklearn.ensemble import RandomForestClassifier
classifier = RandomForestClassifier(n_estimators = 10, criterion = 'entropy')
classifier.fit(X_train, y_train)**
步骤 6:预测测试集结果
在这一步中，classifier.predict()函数用于预测测试集的值，这些值被存储到变量y_pred.
**y_pred = classifier.predict(X_test)
y_pred**
步骤 7:混淆矩阵和准确性
这是分类技术中最常用的一步。在这里，我们看到了训练模型的准确性，并绘制了混淆矩阵。
混淆矩阵是一个表，用于显示当测试集的真实值已知时，对分类问题的正确和错误预测的数量。它的格式如下
来源—自己
真实值是正确预测的次数。
**from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)from sklearn.metrics import accuracy_score
print ("Accuracy : ", accuracy_score(y_test, y_pred))
cm>>Accuracy : 0.9625
>>array([[55, 3],
[ 0, 22]])**
从上面的混淆矩阵，我们推断，在 80 个测试集数据中，77 个被正确分类，只有 3 个被错误分类，留给我们 96.25%的准确率。
步骤 8:将实际值与预测值进行比较
在这个步骤中，创建一个 Pandas DataFrame 来比较原始测试集( y_test )和预测结果( y_pred )的分类值。
**df = pd.DataFrame({'Real Values':y_test, 'Predicted Values':y_pred})
df>>
Real Values Predicted Values
1 1
1 1
0 0
0 0
0 0
... ... ... ...
1 1
0 1
0 0
0 0
1 1**
这个步骤是一个额外的步骤，它不像混淆矩阵那样提供很多信息，并且主要用于回归以检查预测值的准确性。试着找出错误预测的值！
步骤 9:可视化结果
在最后一步中，我们将随机森林分类模型的结果可视化在一个图表上，该图表与两个区域一起绘制。
**from matplotlib.colors import ListedColormap
X_set, y_set = X_test, y_test
X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() - 1, stop = X_set[:, 0].max() + 1, step = 0.01),
np.arange(start = X_set[:, 1].min() - 1, stop = X_set[:, 1].max() + 1, step = 0.01))
plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),
alpha = 0.75, cmap = ListedColormap(('red', 'green')))
plt.xlim(X1.min(), X1.max())
plt.ylim(X2.min(), X2.max())
for i, j in enumerate(np.unique(y_set)):
plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1],
c = ListedColormap(('red', 'green'))(i), label = j)
plt.title('SVM Classification')
plt.xlabel('Age')
plt.ylabel('EstimatedSalary')
plt.legend()
plt.show()**
随机森林分类
在这个图中，有两个区域。 红色 区域表示 0 ，由未购买该产品的人组成， 绿色 区域表示 1 ，由已购买该产品的人组成。
如果您仔细观察，我们可以看到测试集中红色的 3 个错误分类的数据点，在特定区域有颜色差异。
结论—
因此，在这个故事中，我们已经成功地构建了一个 随机森林分类 模型，该模型能够根据一个人的年龄和工资来预测他是否会购买一件产品。请随意尝试网上其他各种常见的分类数据集。
我还附上了我的 github 资源库的链接，你可以在那里下载这个 Google Colab 笔记本和数据文件供你参考。
这是一个由 Python 代码组成的知识库，用于构建不同类型的分类模型，以评估和…
github.com](https://github.com/mk-gurucharan/Classification)
您还可以在下面找到该程序对其他分类模型的解释:
在接下来的文章中，我们将会遇到更复杂的回归、分类和聚类模型。到那时，快乐的机器学习！**
机器学习基础:随机森林回归
学习用 Python 构建机器学习中的随机森林回归模型
之前，我已经解释了各种回归模型，如线性、多项式、支持向量和决策树回归。在本文中，我们将浏览随机森林回归应用程序的代码，它是对之前实现的 决策树回归 的扩展。
随机森林算法综述
决策树是一种易于理解和解释的算法，因此单个树可能不足以让模型从中学习特征。另一方面，随机森林也是一种基于“树”的算法，它使用多个决策树的质量特征来进行决策。
因此，它可以被称为一个*【森林】*的树木，因此得名“随机森林”。术语’ Random 是因为这个算法是一个 ‘随机创建的决策树’ 的森林。
决策树算法的一个主要缺点是它会导致过拟合。这个问题可以通过用随机森林回归代替决策树回归来解决。此外，与其他回归模型相比，随机森林算法也非常快速和稳健。
随机森林算法(来源)
简而言之，随机森林算法合并多个决策树的输出，以生成最终输出。
问题分析
用于 决策树回归 的相同数据集在此使用，我们有一个独立变量温度和一个独立变量收入，我们必须预测。在这个问题中，我们必须建立一个随机森林回归模型，该模型将研究冰淇淋店的温度和收入之间的相关性，并根据特定日期的温度预测冰淇淋店的收入。
步骤 1:导入库
照常导入NumPymatplotlib和 熊猫库 。
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
步骤 2:导入数据集
使用函数’ pd.read_csv ‘从我的 github 存储库中导入数据集。在此，我们将自变量(X)分配给’*温度’*列，将因变量(y)分配给’*收入’*列。
dataset = pd.read_csv('[https://raw.githubusercontent.com/mk-gurucharan/Regression/master/IceCreamData.csv'](https://raw.githubusercontent.com/mk-gurucharan/Regression/master/IceCreamData.csv'))X = dataset['Temperature'].values
y = dataset['Revenue'].valuesdataset.head(5)>>Temperature Revenue
24.566884 534.799028
26.005191 625.190122
27.790554 660.632289
20.595335 487.706960
11.503498 316.240194
步骤 3:将数据集分为训练集和测试集
类似于决策树回归模型，我们将拆分数据集，我们使用test_size=0.05，这意味着 500 个数据行( 25 行)中的 5%将仅用作测试集，剩余的 475 行将用作训练集，用于构建随机森林回归模型。
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.05)
步骤 4:在训练集上训练随机森林回归模型
在这一步中，为了训练模型，我们导入了RandomForestRegressor类，并将其赋给了变量regressor。然后，我们使用.fit()函数，通过相应地调整回归变量来拟合 X_train 和 y_train 值。
# Fitting Random Forest Regression to the dataset
from sklearn.ensemble import RandomForestRegressor
regressor = RandomForestRegressor(n_estimators = 10, random_state = 0)
regressor.fit(X_train.reshape(-1,1), y_train.reshape(-1,1))
第五步:预测结果
在这一步中，我们使用regressor.predict函数预测模型在训练集值上训练的测试集的结果，并将其分配给’ y_pred’ 。
y_pred = regressor.predict(X_test.reshape(-1,1))
步骤 6:将实际值与预测值进行比较
在这一步中，我们将在 Pandas 数据帧中比较并显示 y_test 的值为’真实值，y_pred 的值为’预测值。
df = pd.DataFrame({'Real Values':y_test.reshape(-1), 'Predicted Values':y_pred.reshape(-1)})
df>>
Real Values Predicted Values
534.622865 510.602018
542.608070 558.764770
618.457277 653.356430
460.402500 449.302331
759.377432 728.037404
631.318237 649.712332
572.672047 583.685756
494.627437 503.075097
250.131728 239.372956
594.651009 635.653662
383.956240 384.531416
491.230603 503.075097
875.019348 933.984685
273.073342 224.659296
500.925064 498.355934
191.623312 193.223331
691.516541 726.817925
421.621505 420.997198
636.298374 653.945550
321.848273 276.772845
283.679657 275.805778
608.936345 589.542982
212.591740 239.372956
594.804871 541.164031
500.065779 524.649546
从上述值，我们推断该模型能够以良好的准确度预测 y_test 的值，尽管它可以通过调整超参数如n_estimators和max_depth来改进。我把这些参数交给你们来处理，以提高随机森林回归模型的准确性。
步骤 7:可视化随机森林回归结果
温度与收入(随机森林回归)
在该图中，实际值用" 、红色 “绘制，预测值用” 、绿色 "绘制。决策树回归模型的绘图也是用 黑色 颜色绘制的。
随机森林回归
我附上了我的 github 资源库的链接，你可以在那里找到 Google Colab 笔记本和数据文件供你参考。
GitHub 是超过 5000 万开发人员的家园，他们一起工作来托管和审查代码、管理项目和构建…
github.com](https://github.com/mk-gurucharan/Regression)
我真的希望我已经用一个例子解释了构建决策树回归模型的 ML 代码。
您还可以在下面找到该程序对其他回归模型的解释:
在接下来的文章中，我们将会遇到更复杂的回归、分类和聚类模型。到那时，快乐的机器学习！
机器学习基础:简单线性回归
学习简单线性回归的基本机器学习程序。
在数据科学编程的最初几天，人们可能会遇到术语“回归”。在这个故事中，我想用一个常见的例子来解释非常基本的“”的程序代码。
概述—
在统计学中， 线性回归 是一种对标量响应(或因变量)与一个或多个解释变量(或自变量)之间的关系进行建模的线性方法。在我们的例子中，我们将经历简单的线性回归。
简单线性回归的形式为y = wx + b，其中 y 为因变量， x 为自变量， w 和 b 为训练参数，在训练过程中需要对其进行优化，以获得准确的预测。
现在让我们应用机器学习来训练一个数据集，根据年的经验来预测 工资 。**
步骤 1:导入库
在第一步中，我们将导入 pandas 库，该库将用于存储 pandas 数据帧中的数据。 matplotlib 用于绘制图形。
**import numpy as np
import matplotlib.pyplot as plt
import pandas as pd**
步骤 2:导入数据集
在这一步中，我们将从我的 github 存储库中下载数据集，其中包含的数据为“Salary_Data.csv”。变量 X 会存储“ 年资 ”，变量会存储“ 工资。dataset.head(5)用于可视化前 5 行数据。
**dataset = pd.read_csv('https://raw.githubusercontent.com/mk-gurucharan/Regression/master/Salary_Data.csv')X = dataset.iloc[:, :-1].values
y = dataset.iloc[:, -1].valuesdataset.head(5)>>
YearsExperience Salary
1.1 39343.0
1.3 46205.0
1.5 37731.0
2.0 43525.0
2.2 39891.0**
步骤 3:将数据集分为训练集和测试集
在这一步中，我们必须将数据集分为训练集和测试集，前者将训练线性回归模型，后者将应用训练好的模型来可视化结果。在此，test_size=0.2表示数据的 20%将作为 测试集保存，剩余的的 80%将作为 训练集用于训练。**
**from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2)**
步骤 4:在训练集上训练简单线性回归模型
第四步，导入类LinearRegression，并将其赋给变量 “回归量” 。regressor.fit()功能配有 X_train 和 Y_train ，模型将在其上进行训练。
**from sklearn.linear_model import LinearRegression
regressor = LinearRegression()
regressor.fit(X_train, y_train)**
步骤 5:预测测试集结果
在这一步中，regressor.predict()函数用于预测测试集的值，这些值被存储到变量y_pred.
**y_pred = regressor.predict(X_test)**
步骤 6:将测试集与预测值进行比较
在这个步骤中，创建一个 Pandas DataFrame 来比较原始测试集( y_test )和预测结果( y_pred )的工资值。
**df = pd.DataFrame({'Real Values':y_test, 'Predicted Values':y_pred})
df>>
Real Values Predicted Values
109431.0 107621.917107
81363.0 81508.217112
93940.0 82440.849255
55794.0 63788.206401
66029.0 74047.159970
91738.0 89901.906396**
我们可以看到，预测的工资非常接近实际工资值，可以得出结论，该模型已经过良好的训练。
第七步:可视化结果
在最后一步中，我们将 实际 和 预测 工资值的结果以及绘制的图表上的线性回归线可视化。
**plt.scatter(X_test, y_test, color = 'red')
plt.scatter(X_test, y_pred, color = 'green')
plt.plot(X_train, regressor.predict(X_train), color = 'black')
plt.title('Salary vs Experience (Result)')
plt.xlabel('YearsExperience')
plt.ylabel('Salary')
plt.show()**
薪水与经验
在该图中，实际值用“ 红色 绘制，预测值用“ 绿色 绘制。生成的线性回归线以“ 黑色 ”颜色绘制。
结论—
因此，在这个故事中，我们已经成功地构建了一个 简单线性回归 模型，该模型根据员工的“工作经验”来预测他们的“工资”,并将结果可视化。
我还附上了我的 github 资源库的链接，你可以在那里下载这个 Google Colab 笔记本和数据文件供你参考。
GitHub 是超过 5000 万开发人员的家园，他们一起工作来托管和审查代码、管理项目和构建…
github.com](https://github.com/mk-gurucharan/Regression)
您还可以在下面找到该程序对其他回归模型的解释:
在接下来的文章中，我们将会遇到更复杂的回归、分类和聚类模型。到那时，快乐的机器学习！**
机器学习基础:支持向量机(SVM)分类
了解支持向量机制，并将其应用于实时示例。
在之前的故事中，我已经解释了各种 回归 模型的实现程序。此外，我还描述了逻辑回归和 KNN 分类模型的实现。在本文中，我们将通过一个清晰的例子来了解 SVM 分类的算法和实现。
SVM 分类概述
支持向量机(SVM)分类类似于我在之前的故事中解释过的支持向量机。在 SVM，用来分隔类的线被称为 超平面 。超平面任意一侧最接近超平面的数据点称为 支持向量 ，用于绘制边界线。
在 SVM 分类中，数据可以是线性的，也可以是非线性的。在 SVM 分类器中可以设置不同的内核。对于线性数据集，我们可以将内核设置为’ linear '。
另一方面，对于非线性数据集，有两个核，即’ rbf 和’多项式’。在这种情况下，数据被映射到更高的维度，这使得绘制超平面更容易。之后，它被降低到较低的维度。
SVM 机制(信息来源——本人)
从上图中，我们可以看到有两类形状，矩形和圆形。由于很难在 2D 平面中绘制 SVM 线，我们将数据点映射到更高维度(3D 平面)，然后绘制超平面。然后，用红色绘制的 SVM 分类器将它还原到原始平面。
通过这种方式，SVM 分类器可用于从给定的数据集中对数据点进行分类，确定其所属的类别。让我们用这个算法来解决一个现实世界的问题。
问题分析
在 SVM 分类模型的这个实现中，我们将使用由三列组成的社交网络广告数据集。前两列是自变量，即’ 【年龄】’ 和’ 【估计销售额】’ ，最后一列是因变量’ 【购买量】’ ，以二进制格式表示个人是否购买了产品(1)或(0)。
在这个问题中，我们必须为一家公司建立一个 SVM 分类模型，该模型将对特定年龄和特定工资的用户是否会购买他们的特定产品进行分类。现在让我们来看一下模型的实现。
步骤 1:导入库
和往常一样，第一步总是包括导入库，即 NumPy、Pandas 和 Matplotlib。
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
步骤 2:导入数据集
在这一步中，我们将从我的 github 存储库中获取存储为[SocialNetworkAds.csv](https://github.com/mk-gurucharan/Classification/blob/master/SocialNetworkAds.csv) 的数据集，并将其存储到变量 dataset 中。然后我们将相应的变量赋给 X 和 y。最后，我们将看到数据集的前 5 行。
dataset = pd.read_csv('[https://raw.githubusercontent.com/mk-gurucharan/Classification/master/SocialNetworkAds.csv'](https://raw.githubusercontent.com/mk-gurucharan/Classification/master/SocialNetworkAds.csv'))X = dataset.iloc[:, [0, 1]].values
y = dataset.iloc[:, 2].valuesdataset.head(5)>>
Age EstimatedSalary Purchased
19 19000 0
35 20000 0
26 43000 0
27 57000 0
19 76000 0
步骤 3:将数据集分为训练集和测试集
该数据集中有 400 行。我们将把数据分成训练集和测试集。这里的test_size=0.25表示*数据的 25%将作为 测试集 保存，剩余的 75%将作为 训练集 用于训练。因此，测试集中大约有 100 个数据点。*
**from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25)**
步骤 4:特征缩放
这个特征缩放步骤是一个额外的步骤，当我们将 X 的值缩小到一个更小的范围时，它可以提高程序的速度。在这里，我们将X_train和X_test缩小到-2 到+2 的小范围。例如，工资 75000 按比例缩减为 0.16418997。
**from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)**
步骤 5:在训练集上训练 SVM 分类模型
**一旦训练测试准备就绪，我们就可以导入 SVM 分类类并使训练集适合我们的模型。类别SVC被分配给变量classifier。这里用的核是“***RBF”*核，代表径向基函数。还有其他几种核，例如线性核和高斯核，也可以实现。然后使用classifier.fit() 功能来训练模型。
**from sklearn.svm import SVC
classifier = SVC(kernel = 'rbf', random_state = 0)
classifier.fit(X_train, y_train)**
步骤 6:预测测试集结果
在这一步中，classifier.predict()函数用于预测测试集的值，这些值被存储到变量y_pred.
**y_pred = classifier.predict(X_test)
y_pred**
步骤 7:混淆矩阵和准确性
这是分类技术中最常用的一步。在这里，我们看到了训练模型的准确性，并绘制了混淆矩阵。
混淆矩阵是一个表，用于显示当测试集的真实值已知时，对分类问题的正确和错误预测的数量。它的格式如下
来源—自己
真实值是正确预测的次数。
**from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)from sklearn.metrics import accuracy_score
print ("Accuracy : ", accuracy_score(y_test, y_pred))
cm>>Accuracy : 0.9>>array([[59, 6],
[ 4, 31]])**
从上面的混淆矩阵中，我们推断，在 100 个测试集数据中，90 个被正确分类，10 个被错误分类，留给我们 90%的准确率。
步骤 8:将实际值与预测值进行比较
在这个步骤中，创建一个 Pandas DataFrame 来比较原始测试集( y_test )和预测结果( y_pred )的分类值。
**df = pd.DataFrame({'Real Values':y_test, 'Predicted Values':y_pred})
df>>
Real Values Predicted Values
1 1
0 0
0 0
1 1
0 0
... ... ... ...
1 1
1 1
0 0
0 0
1 1**
这个步骤是一个额外的步骤，它不像混淆矩阵那样提供很多信息，并且主要用于回归以检查预测值的准确性。
步骤 9:可视化结果
在最后一步中，我们将 SVM 分类模型的结果可视化在一个沿着两个区域绘制的图上。
**from matplotlib.colors import ListedColormap
X_set, y_set = X_test, y_test
X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() - 1, stop = X_set[:, 0].max() + 1, step = 0.01),
np.arange(start = X_set[:, 1].min() - 1, stop = X_set[:, 1].max() + 1, step = 0.01))
plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),
alpha = 0.75, cmap = ListedColormap(('red', 'green')))
plt.xlim(X1.min(), X1.max())
plt.ylim(X2.min(), X2.max())
for i, j in enumerate(np.unique(y_set)):
plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1],
c = ListedColormap(('red', 'green'))(i), label = j)
plt.title('SVM Classification')
plt.xlabel('Age')
plt.ylabel('EstimatedSalary')
plt.legend()
plt.show()**
SVM 分类
在这个图中，有两个区域。 红色 区域表示 0 ，由未购买该产品的人组成， 绿色 区域表示 1 ，由已购买该产品的人组成。由于我们选择了非线性核(rbf ),我们得到的区域没有被线性线分开。
如果您仔细观察，我们可以看到测试集中的 10 个错误分类的数据点，它们在特定区域的颜色有所不同。
结论—
因此，在这个故事中，我们已经成功地建立了一个 SVM 分类 模型，它能够根据一个人的年龄和工资来预测他是否会购买一件产品。请随意尝试网上其他各种常见的分类数据集。
我还附上了我的 github 资源库的链接，你可以在那里下载这个 Google Colab 笔记本和数据文件供你参考。
这是一个由 Python 代码组成的知识库，用于构建不同类型的分类模型，以评估和…
github.com](https://github.com/mk-gurucharan/Classification)
您还可以在下面找到该程序对其他分类模型的解释:
- 逻辑回归
- K-最近邻(KNN)分类
- 支持向量机(SVM)分类
- 朴素贝叶斯分类(即将推出)
- 随机森林分类(即将推出)
在接下来的文章中，我们将会遇到更复杂的回归、分类和聚类模型。到那时，快乐的机器学习！**
机器学习基础:支持向量回归
学会在机器学习中建立支持向量回归(SVR)模型，并分析结果。
在前面的故事中，我解释了用 Python 构建线性和多项式回归模型的机器学习程序。在本文中，我们将介绍基于非线性数据构建支持向量回归模型的程序。
SVR 概述
支持向量机(SVM)是一种非常流行的机器学习算法，用于回归和分类。支持向量回归类似于线性回归，在 SVR 中直线的方程是y= wx+b，这条直线被称为 超平面 。超平面任意一侧最接近超平面的数据点称为 支持向量 ，用于绘制边界线。
与试图最小化实际值和预测值之间的误差的其他回归模型不同，SVR 试图在阈值(超平面和边界线之间的距离)内拟合最佳直线。因此，我们可以说 SVR 模型满足条件-a < y-wx+b < a。它使用具有此边界的点来预测值。
对于非线性回归，核函数将数据转换到更高维度，并执行线性分离。这里我们将使用 rbf 内核。
在这个例子中，我们将完成 支持向量回归(SVM) 的实现，其中我们将根据学生投入学习的小时数来预测他或她的分数。
问题分析
在这个数据中，我们有一个自变量学习时间和一个因变量分数。在这个问题中，我们必须使用这些数据训练一个 SVR 模型，以了解学习时间和学生分数之间的相关性，并能够根据学生投入学习的时间预测他们的分数。
步骤 1:导入库
在第一步中，我们将导入构建 ML 模型所需的库。导入 NumPy 库和 matplotlib 。另外，我们导入了 熊猫 库用于数据分析。
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
步骤 2:导入数据集
在这一步，我们将使用 pandas 来存储从我的 github 存储库中获得的数据，并使用函数“ pd.read_csv ”将其存储为 Pandas DataFrame。
我们遍历我们的数据集，将自变量(x)分配给列“”的学习时间，将因变量(y)分配给最后一列，即要预测的“”标记。**
**dataset = pd.read_csv('[https://raw.githubusercontent.com/mk-gurucharan/Regression/master/SampleData.csv'](https://raw.githubusercontent.com/mk-gurucharan/Regression/master/SampleData.csv'))X = dataset.iloc[:, 0].values
y = dataset.iloc[:, 1].values
y = np.array(y).reshape(-1,1)dataset.head(5)>>Hours of Study Marks
32.502345 31.707006
53.426804 68.777596
61.530358 62.562382
47.475640 71.546632
59.813208 87.230925**
我们使用相应的。iloc 函数对数据帧进行切片，以将这些指标分配给 X 和 y。在这种情况下，小时的学习时间被视为独立变量，并被分配给 X。要预测的因变量是最后一列，即标记的，它被分配给 y。我们将使用reshape(-1,1)将变量 y 整形为列向量。
步骤 3:特征缩放
大多数可用的数据通常具有不同的范围和大小，这使得建立模型很困难。因此，数据的范围需要被标准化为更小的范围，这使得模型在训练时更加准确。在该数据集中，数据被归一化到接近零的小值之间。例如， 87.23092513 的分数归一化为 1.00475931 ，而 53.45439421 的分数归一化为 -1.22856288 。
**from sklearn.preprocessing import StandardScaler
sc_X = StandardScaler()
sc_y = StandardScaler()
X = sc_X.fit_transform(X.reshape(-1,1))
y = sc_y.fit_transform(y.reshape(-1,1))**
在大多数常见的回归和分类模型中，特征缩放主要是在内部执行的。支持向量机不是一个常用的类，因此数据被标准化到一个有限的范围。
步骤 4:在训练集上训练支持向量回归模型
在构建任何 ML 模型时，我们总是需要将数据分成训练集和测试集。将使用训练集的值训练 SVR 模型，并在测试集上测试预测。在 100 行中，80 行用于训练，并且在由条件test_size=0.2给出的剩余 20 行上测试模型
**from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2)**
步骤 5:在训练集上训练支持向量回归模型
在此，函数 SVM 被导入并被赋给变量regressor。使用内核*【RBF】*(径向基函数)。径向基函数核用于将非线性引入到支持向量回归模型中。这样做是因为我们的数据是非线性的。regressor.fit用于通过相应地调整数据来拟合变量 X_train 和 y_train 。
**from sklearn.svm import SVR
regressor = SVR(kernel = 'rbf')
regressor.fit(X_train.reshape(-1,1), y_train.reshape(-1,1))**
步骤 6:预测测试集结果
在这一步中，我们将使用构建的 SVR 模型来预测测试集的分数。regressor.predict函数用于预测 X_test 的值。我们将预测值赋给 y_pred。我们现在有两个数据，y_test(真实值)和 y_pred(预测值)。
**y_pred = regressor.predict(X_test)
y_pred = sc_y.inverse_transform(y_pred)**
步骤 7:将测试集与预测值进行比较
在这一步中，我们将在 Pandas DataFrame 中将每个 X_test 的 y_test 的值显示为 真实值 ，将 y_pred 值显示为 预测值 。
**df = pd.DataFrame({'Real Values':sc_y.inverse_transform(y_test.reshape(-1)), 'Predicted Values':y_pred})
df>>
Real Values Predicted Values
31.707006 53.824386
76.617341 61.430210
65.101712 63.921849
85.498068 80.773056
81.536991 72.686906
79.102830 60.357810
95.244153 89.523157
52.725494 54.616087
95.455053 82.003370
80.207523 81.575287
79.052406 67.225121
83.432071 73.541885
85.668203 78.033983
71.300880 76.536061
52.682983 63.993284
45.570589 53.912184
63.358790 76.077840
57.812513 62.178748
82.892504 64.172003
83.878565 93.823265**
我们可以看到，预测值与测试集的真实值之间存在显著偏差，因此我们可以得出结论，该模型并不完全适合以下数据。
步骤 8:可视化 SVR 结果
在最后一步中，我们将可视化使用给定数据构建的 SVR 模型，并在图上绘制“ y ”和“ y_pred ”的值，以可视化结果
**X_grid = np.arange(min(X), max(X), 0.1)
X_grid = X_grid.reshape((len(X_grid), 1))
plt.scatter(sc_X.inverse_transform(X_test), sc_y.inverse_transform(y_test.reshape(-1)), color = 'red')
plt.scatter(sc_X.inverse_transform(X_test), y_pred, color = 'green')plt.title('SVR Regression')
plt.xlabel('Position level')
plt.ylabel('Salary')
plt.show()**
**
****
学习时间与分数(SVR)**
在该图中，实际值用“ 红色 绘制，预测值用“ 绿色 绘制。SVR 模型的绘图也以 黑色 颜色显示。
我附上了我的 github 资源库的链接，你可以在那里找到 Google Colab 笔记本和数据文件供你参考。
GitHub 是超过 5000 万开发人员的家园，他们一起工作来托管和审查代码、管理项目和构建…
github.com](https://github.com/mk-gurucharan/Regression)
希望我已经清楚地解释了用非线性数据集构建支持向量回归模型的程序。
您还可以在下面找到该程序对其他回归模型的解释:
在接下来的文章中，我们将会遇到更复杂的回归、分类和聚类模型。到那时，快乐的机器学习！**
机器学习在看不见的数据上击败了 BTC/USDT，即使有交易费和滑点。
物理学研究如何变成人工智能模型，如何变成密码交易。
在一盘棋中，为了赢，必须有人输。这同样适用于高度不稳定的数字市场——比特币。投机者同时买入和卖出，肯定有人错了。来源
前言
有很多关于将机器学习应用于加密交易的实验文章，但很难找到一个具有现实方法论的文章。理想情况下，结果应该来自实际交易所的交易历史，或者来自带有看不见的数据和交易费用的模拟。这就是我写这篇文章的原因——我想告诉你我是如何进行金融市场研究的，展示一些研究结果，并最终向你展示实际结果。所有这些都是基于现实的假设——包括交易费用、滑点和看不见的数据。
看到什么不起作用
我曾经从事各种物理实验——最著名的是欧洲核子研究中心的 ATLAS 项目(使用大型强子对撞机，世界上最大和最高能量的粒子对撞机，也是世界上最大的机器)。我来到那里时是一名物理系学生，后来成为一名数据科学家，研究事件拓扑分类问题。2018 年夏天，我开始对股票交易感兴趣。我知道我的数据科学直觉和编程技能可能是有用的，所以使用数学模型和一些自动化的想法很自然地出现了。我花了一个夏天寻找有用的文章，但很难找到有趣的东西。如果有人声称某样东西有效，我无法以任何方式复制它。
在过去的 1.5 年里，我阅读了大约 100 篇关于金融领域机器学习的文章。我见过有人使用 LSTMs，路径积分，各种强化学习，但我没有发现任何异常的性能。尽管如此，看看什么不起作用还是很有用的，这样你就不必浪费时间亲自尝试了。
市场行为
有效市场假说认为资产价格反映了所有可获得的信息。如果这个假设是真的，那么只有那些拥有公众无法获得的信息的内部人士才能战胜市场，并且仅仅通过交易赚钱。在一次采访中，数学家兼对冲基金亿万富翁詹姆斯·西蒙斯强烈反对这一假设。他指出，在公开可用的数据中存在一些模式，可以用来持续战胜市场。他指出这些模式来来去去。一旦人们开始滥用某些统计异常，异常就会消失。这是因为我们的交易影响市场——尤其是当交易量很大的时候。一个已经消失的异常现象的例子是 20 世纪 80 年代许多商品随季节变化的趋势。人们可以在价格高于均线时买入，在价格低于均线时卖出，这样每年都能赚钱。
图 1:1984 年一种典型商品(糖)的价格，当时许多商品都有明显的季节性影响。原始的趋势跟踪系统可以让投资者在市场上获得优势。如今，价格模式要复杂得多。来源
西蒙的观点很有道理——一群人的行为有一定的模式，投资者也不例外。因此，我们可以利用人们在某种程度上可以用正确的数学模型预测的优势(数学模型需要不断进化，就像那群人一样)。这是否意味着这种模式可以在没有风险和没有交易量限制的情况下赚钱？显然不是。主要由复兴科技(Renaissance Technologies)的基金员工管理的梅达莲基金(Medallion fund)因其在华尔街的最佳记录而闻名。它主要面向基金员工，而不是每个投资者，原因是他们必须引入约 100 亿 dollars⁴.的资本限制在这种规模下，很难不对市场产生太大影响，这会扰乱模型本身的数据，进而导致预测不正确。越来越多的领先基金引入了类似的资本限制，这为较小的基金获得必要的资本创造了机会。
另一方面，风险不可能降低到零，因为首先，没有人知道市场的确切状态(要知道市场的状态，我们需要知道所有参与者的状态，这是不可能的)，也没有人确切知道市场未来会如何反应(某些行动的蝴蝶效应是可能的)。然而，通过引入随机变量，这是概率论的创造，我们可以在一定程度上建立这样的市场模型。风险无法消除，但其降低是可以控制的。由于我们的系统中存在随机变量，短期情景可能会有很大变化。即使是最好的系统也可能在短期内亏损。例如，在这份年度财务报告中，report⁵ JP 摩根称，由于进行了不良交易，他们在一天内损失了大约 1 亿美元。重要的是长期的结果。
可用信息:技术与基本面
在深入研究可以将信息用于我们的优势(即降低投资风险)的模型之前，让我们先回顾一下可用的信息。证券交易所记录了他们调解的每一笔交易，对公众隐瞒了他们的价格和交易量数据数据集，只愿意以几十万美元的价格出售(通常按年收费)。然而，加密货币交易所要透明得多。足够熟练的程序员应该能够通过使用他们的 API“免费”访问每个主要加密货币交易所的每个硬币对(从众所周知的比特币和莱特币到最近的储备权令牌 RSR 等新的热门令牌)上的每个交易，不计算时间和精力。如果我们假设价格大致反映了市场的状态，我们不需要任何其他信息来建立一个有效的交易系统。然而，实践表明，这种系统也可以从地缘政治局势/立法行动/财务报告等分析中受益匪浅。(通常指基础研究)。例如，历史上，黄金在冲突爆发时会上涨。
首先模拟市场
上世纪 80 年代，领先的量化对冲基金使用线性模型。转向隐马尔可夫模型，后来完全接受了机器学习 solutions⁶.没有对冲基金吹嘘他们的方法，但如果你持续观察他们足够长的时间，并关注细节，你就能到处发现小信息。这是对他们 website⁷:的一个研究科学家职位的描述
研究科学家:使用机器学习、应用数学和现代统计学技术来开发和完善金融市场模型，并基于这些模型开发交易算法。
乍一看，这似乎不重要，但请密切注意这一部分:“开发和改进模型[……]并基于这些模型开发交易算法”。他们明确区分了市场模型和交易算法。通过我的研究，我也意识到，目前，这可能是建立交易系统最有效的方式。首先，尝试建立一个市场模型。试着预测某些市场状态，某些变量，行为，然后，根据你的预测建立一个交易算法。如果你开发了一个黑匣子，它只是简单地获取原始价格数据，不经过中间步骤就做出交易决定，那么理解和修改起来就会困难得多。相信我——你必须修改你的第一个系统，因为没有人能一次就做对。此外，记住，要维护一个交易系统，你必须定期修改它，这是上一节的结论(根据霍华德摩根，复兴科技的原始团队成员之一，更新他们的系统 monthly⁸).
特色工程
如果你遵循一条规则，即长期决策应该由长期模式驱动，短期决策应该主要由短期模式驱动——时间投资窗口越短，模式数据集就越大。如果我们真的在短期内(亚秒甚至毫秒)，那么模型往往会工作得更好(由于大量的可用数据点)，然而，这导致昂贵的计算机基础设施能够非常精确地进行计算和执行订单。由于我不是通过加入现有的公司，而是创建自己的公司来开始我的财务之旅，我个人专注于分分秒秒的时间窗口，这很简单，因为 4 人团队的技术限制。
如果我们从每分钟提取一个数据点(一个数据点可以是一列数字，例如买/卖量、给定分钟内按量加权的平均价格、最低价格、最高价格等。)那么我们每年剩下大约 50 万个数据点。相比之下，在我在欧洲核子研究中心从事分析工作期间，我们过去常常基于数亿个数据点来制作神经网络模型。那时，我们可以输入原始数据，但在分钟到分钟价格的情况下，它们必须得到适当的简化，以避免不必要的过度拟合——使模型无法在看不见的数据上正常工作。这些数据点的空间表示可能会极大地影响性能。例如，为了表示音频，查看频率要容易得多。如果金融世界中的某些东西可行，那么人们不太可能与他人分享所有细节——如果你想成功，你需要有创造力，并找到一种合适的空间表示(所谓的特征工程)。
避免偏差和过拟合
虽然可以使用 k-fold 交叉验证等解决方案在整个数据集上可靠地测试模型的性能，但在许多现有文章中，这通常是前瞻偏差的来源。为了透明起见，我将比特币价格分为两个数据集:训练和测试(算法和我都看不见的数据)。2019 年 10 月 1 日之后的数据没有用于训练/拟合模型的参数，我将介绍该模型的结果。在欧洲粒子物理研究所，有一条规定，所有的物理分析都是首先根据前一年的数据集准备的，任何研究人员(除了极少数例外)都无法获得最新的数据。建立这条规则是为了防止各种偏见。例如，我们知道价格在测试数据集中下降，所以(可能只是下意识地)我们使模型更加厌恶风险。在我的工作中，我也遵循了这一规则，在大多数情况下，我没有查看该模型建立之前的最新数据(从 2019 年 10 月 1 日起)。该模型目前与我和我的客户的真实交易所交易相关联——根据定义，这种数据没有任何偏见，我将展示其中的一些数据来支持模拟。
避免过度拟合的一个方法是引入一个二值随机变量“x ”,如果“x=1 ”,则允许订单进入模拟，如果“x=0 ”,则阻止订单。在您的策略中没有这样的变量相当于它的平均值为 1。应该尝试将平均值设置为 0.1 或 0.5，看看性能会发生什么。这是过度策略和/或交易不足以达到统计显著性的真正杀手。下面我们来介绍一下性能比 R(x)如下:
等式 1:R(x)—x 函数中的性能比。除以 x 作为归一化。
其中 P(x)是 x 的函数，鲁棒系统的 R(x)常数应在 1 左右。
模拟现实交易费用
任何现实市场模型的基本特征是交易费用。除了向交易所支付佣金，我们还必须考虑“延期费”，也称为滑点。我们永远不能使用最后看到的交易价格进行买卖。计算预测和执行订单的基础设施总有一个反应时间。最后但并非最不重要的一点是，存在“价差”——某一订单深度的买卖差价(在交易量巨大的情况下尤其重要)。总结一下，最终费用(FF)为:FF =交易费(TF)，延误费(DF)，点差费(SF)。
结果
不同最终费用的2019 年 4 月 24 日至2020 年 1 月 15 日期间的模拟结果如下所示。
图 2:不同最终费用的模型和“买入并持有”策略在比特币上的性能比较。每月 81 笔交易使得业绩对最终费用非常敏感。
HitBTC 向(接受者/制造者)提供 0.07%的交易费(如果你是验证用户)，没有任何额外的交易量要求。同样，币安提供 0.075%(如果你持有 BNB，但其大多数用户持有)。我们的系统在几秒钟内执行一笔交易，平均延迟费用约为 0.015%(如果你的策略是反向策略，这可以低得多，甚至是负数)。对于小投资者来说，价差约为 0.01%。SF 随着资本的增加而增加，但交易费用随着交易量的增加而减少，因此 FF 在资本方面相对稳定，约为 0.095%。你可以看到，这是在一个有利可图的范围内。
表 1:B&H 对 BTC/USDT 的策略与 FFF=0.10%的模型的比较。
这种程度的风险降低只能通过加密市场上的活跃交易来实现。所有主要因素都高度相关(从 0.4 到 0.9)，所以像资产多样化和再平衡这样的标准风险降低方法在 well⁹.并不适用
如何纳入基本面投入并多样化
如果你进行基本面研究，研究结果表明市场会上涨或下跌，那么就有办法增加或减少策略与市场的相关性。
假设我们的度量“m”是:
情商。2:将 m 度量为利润 P 和风险 D 的 n 次方之比。
对于 n=1，我们有一个平衡策略，风险和利润一样重要。如果我们设置 n <1 we will make our strategy riskier, thus indirectly increasing the correlation with the market. Similarly, n> 1 将减少相关性。另一种方法，一种更直接的强制关联/去关联的方法是在策略方面使我们的投资组合多样化。我们可以在市场资产中持有一定比例，或者从投资中撤出，而不是将我们的所有资本都投入到模型中。参见下图和下表进行比较。
图 3:混合策略之间的比较。使用买入并持有(B & H)的策略在明显上升趋势期间(2019 年 4 月至 6 月)表现优于模型。
表 2: 混合策略之间的绩效比较。在策略投资组合中加入 B & H 会增加风险，降低回报，但如果我们预期上涨趋势，这可能是有用的。风险以最大提款来衡量。
接下来是什么？
由于我每天收集越来越多的数据，我将在 2020 年 3 月进一步提高决策的分辨率，在 1 分钟内达到 4 个预测/决策。这将使模型对更快速的运动更敏感，到目前为止，这种运动在 2020 年非常频繁。
注来自《走向数据科学》的编辑: 虽然我们允许独立作者根据我们的 规则和指导方针 发表文章，但我们不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的 读者术语 。
来源:
[2] 面试可在线获得
[3] 面试可在线获得
[5] 摩根大通年度报告
[6]格雷戈里·祖克曼，《解决市场的人》(2019)
[7] rentec 网站
在线采访
[9] 币安年报
GCP 上的机器学习—选择 GPU 来训练您的模型
GCP GPU 概览——价格、性能、效率、折扣
G oogle 云平台提供了广泛的 GPU 选项可供选择。GPU 可以提高你的 ML 处理能力，尤其是在矩阵计算方面。然而，我们机器上的 CPU 并没有为此进行优化。他们努力处理图像或视频，并且经常会延迟模型训练过程。
照片由 Artiom Vallat 在 Unsplash 上拍摄
在 Tensorflow/Keras 中，NCHW(通道优先)输入的卷积网络需要 GPU 运行。
我的大部分人工智能实验都围绕着人工智能游戏，使用简洁的深度 Q 强化学习或类似的技术。这涉及到对游戏框架的激烈的矩阵操作，这是 CPU 难以应付的。
在切换到 GCP GPU 后，在 CPU 上花费数周时间训练的游戏模型在 GPU 上几天内就完成了。因为它们运行在云上，所以只需使用外部 IP 暴露您的 Tensorboard，无需登录即可轻松监控您的模型。
以下是目前可用的 GPU 选项(2020 年 8 月 10 日)以及它们的价格:—
**NVIDIA® Tesla® T4:** $255.50/month
**NVIDIA® Tesla® K80:** $328.50/month
**NVIDIA® Tesla® P4:** $438.00/month
**NVIDIA® Tesla® P100:** $1,065.80/month
**NVIDIA® Tesla® V100:** $1,810.40/month
本评估仅涵盖特斯拉 T4、K80 和 P4。P100 和 V100 已经被排除在外，仅仅是因为它们对小项目和业余爱好者来说过于昂贵。
注意 :并非所有 GPU 在所有 GCP 地区都可用。您可能希望根据您所使用的 GPU 来更改区域。
NVIDIA Tesla T4—圣杯|首选
特斯拉 T4 是圣杯——它既便宜又高效。它已经成为我为任何 ML 模型设置 GCP 环境的首选。
这是使用 Tensorflow 2.2.0-rc0(在特斯拉 T4 上)运行 DDQN 的 Tensorboard 输出:最高得分:406
Model: "sequential"_________________________________________________________________Layer (type) Output Shape Param # =================================================================conv2d (Conv2D) (None, 32, 20, 20) 8224 _________________________________________________________________conv2d_1 (Conv2D) (None, 64, 9, 9) 32832 _________________________________________________________________conv2d_2 (Conv2D) (None, 64, 7, 7) 36928 _________________________________________________________________flatten (Flatten) (None, 3136) 0 _________________________________________________________________dense (Dense) (None, 512) 1606144 _________________________________________________________________dense_1 (Dense) (None, 4) 2052 =================================================================
作者图片
Link to Tensorboard: [https://tensorboard.dev/experiment/1yrW70A0QHertoJDVZk1ig/#scalars&tagFilter=rew](https://tensorboard.dev/experiment/1yrW70A0QHertoJDVZk1ig/#scalars&tagFilter=rew)
你可以观察到训练过程在短短 2 天内就在突围游戏中取得了接近 300 分的成绩。
特斯拉 T4 的另一个优点是，你可以让它们运行更长时间，以获得持续的折扣，因为它们很便宜(稍后讨论)。
比较 T4 和 P4 的 K80
与 P4 的 K80 相比，特斯拉 T4 是一款相对较新的车型。
上市日期:
**特斯拉 T4—**2018 年 9 月
特斯拉 P4—2016 年 9 月
特斯拉 K80s—2014 年 11 月
在 Tensorflow 分布式训练中，这些在多个 GPU 上的表现如何，此处尚未评估。
但是就性能而言，Atari Breakout 模型的 DDQN 在所有 3 个 GPU 上花费了类似的时间来完成，性能没有重大差异。
Github Link to my project: [https://github.com/komal-SkyNET/ai-neural-networks/tree/master/ai-atari](https://github.com/komal-SkyNET/ai-neural-networks/tree/master/ai-atari)
持续折扣——一定要小心这些！
持续折扣提供大幅折扣，让您的实例运行更长时间。这个是按月计算的。
*作者图片:*使用特斯拉 T4 GPU 计算引擎实例的成本估算(来自 GCP 控制台)
如图所示，请注意，仅使用特斯拉 T4 运行虚拟机，您就可以获得近 80 美元的持续折扣。
*More information here:* [https://cloud.google.com/compute/docs/sustained-use-discounts](https://cloud.google.com/compute/docs/sustained-use-discounts?_ga=2.15197878.-1086316627.1594861704)
通过持续折扣，我节省了将近 100 澳元
下面是一个月来运行 GPU 工作负载有/没有持续折扣的比较。注意图表。
不打折→
作者图片:Komal Venkatesh Ganesan
持续折扣→
作者图片:Komal Venkatesh Ganesan
区域与 GPU 选项
请注意，GPU 选项基于区域。如果您发现下拉列表中缺少某个特定的 GPU 选项，您可能需要尝试不同的地区/区域。
区域 VS GPU 选项( 图片作者)
GPU 选项 us-central1-a(缺少 P100) ( 图片由作者提供)
结论
- 特斯拉 T4 既便宜又高效，很容易成为第一选择，其次是 K80 和 P4。但是，它们在分布式培训(使用多个 GPU)中的性能可能会有所不同，不在本评估范围内。
- 持续折扣:只要多运行一会儿您的工作负载，您就可以获得巨大的折扣。调配虚拟机时，通常会显示预测估计值。
2021 年必读的机器学习书籍
看看吧，你为什么要读它们？
“机器学习:计算机能够从经验中学习，而不需要专门编程.”
-Supplychain today
人工智能 和机器学习自这十年以来一直在获得大量牵引力，每个人都想成为这一变化的一部分。企业对该技术的好处很好奇，而专业人士则对机器学习的能力着迷，并渴望提升自己的技能。
无论是哪种情况，总是需要一个起点，还有什么比阅读那些教你技术细节的伟大书籍更好的方法呢？不管你的专业技能如何，你总能找到适合各种人的书籍，无论是技术爱好者还是新手。
机器学习书籍
在本文中，我们将简要介绍一些可以帮助您理解机器学习概念的最佳书籍，并指导您成为这一迷人领域的专家。此外，假设你熟悉编程语言的基础，这些书是灵感的巨大来源，充满了想法和创新。请继续阅读，了解更多信息—
1。绝对初学者的机器学习:简明英语介绍
**作者:**奥利弗·西奥博尔德
出版社 —散点图出版社
**难度等级:**初学者
在这里获取图书——亚马逊
《绝对初学者的机器学习》一书封面
正如标题所解释的，如果你是机器学习的绝对初学者，这本书应该是你的切入点。要求很少到没有编码 或者数学背景，书中所有的概念都已经解释的很清楚了。
示例之后是视觉效果以更友好的方式展示主题，帮助理解 ML 的关键要素。
奥利弗·西奥博尔德在他的书中简化了几个与 ML 相关的复杂主题，如它的基础知识，以及其他技术，如数据清理，回归分析，聚类，偏差，人工神经网络等。这本书还提供了进一步学习的额外资源。
“作为机器的‘Hello World’的分析”
― 奥利弗·西奥博尔德
2.深度学习
**作者:**伊恩·古德菲勒、约舒阿·本吉奥和亚伦·库维尔
出版商— 麻省理工学院出版社
**难度等级:**初学者
在此获取图书— 亚马逊
《深度学习》一书的封面
被认为是一本非常适合初学者的书，它向你介绍了深度学习的广泛主题，同时也涵盖了机器学习的相关方面。
DL 的基本概念在本书中从头开始进行了全面的解释，以便在这个领域中有一个更强的立足点。这本书解释了线性代数的相关概念，概率和信息论，数值计算，行业标准技术，如优化算法，卷积网络，计算机视觉，以及研究课题，如蒙特卡罗方法，配分函数。为了更深入的理解，捆绑了足够的补充材料。
《深度学习》由该领域的三位专家撰写，是唯一一本关于 subject"的综合性书籍——埃隆·马斯克，特斯拉和 SpaceX 的联合创始人兼首席执行官
3.使用 Scikit-Learn、Keras 和 TensorFlow 进行机器学习:构建智能系统的概念、工具和技术(第一版)
**作者:**奥雷连诺
发行方 —奥莱利传媒
**难度等级:**初学者
在这里获取图书——亚马逊
《使用 Scikit-Learn、Keras 和 TensorFlow 进行机器学习》一书的封面
对于任何计划开始学习机器的人或该领域的爱好者来说，这是最畅销的书籍之一。它要求预先了解 Python 编程语言，解释了一些最常用的 ML 库 Scikit-Learn、Keras 和 TensorFlow 2，用于构建智能系统。
直观解释的概念和易于实现的示例使得实际实现和理解更加顺畅。主题包括支持向量机、随机森林、神经网络、深度强化学习、热切执行、时序处理等等。这本书包含了几个库的更新代码示例，以及相关的 API。
**补充:**还可以在 GitHub 上找到带幻灯片的讲座和练习 。
“在机器学习中，这被称为过度拟合:这意味着模型在训练数据上表现良好，但不能很好地概括。”
― 奥雷连·盖伦
这是关于机器学习的最好的书吗？
查看该书的第二版—
4.面向虚拟人的机器学习(Python 和 R 语言)
**作者:**约翰·保罗·穆勒和卢卡·马萨隆
出版者 —为假人
**难度等级:**初学者
在这里获取图书——亚马逊
《面向傻瓜的机器学习(Python 和 R 语言)》一书的封面
著名的**“假人”**系列的所有书籍都对新手非常友好。这本书，就像这个系列的其他书一样，以一种读者容易理解的方式阐述了它的概念。
这本书包括 ML 中的介绍性概念和理论以及所涉及的工具和编程语言。书中涵盖的主题从在 Windows、Linux 和 macOS 上安装 R 开始，然后是矩阵创建、使用矢量和数据帧、使用 RStudio 或 Anaconda 用 R 或 Python 编码。对于数据挖掘和分析的基本概念，这是一本方便的指南。
“作为一种学习，它类似于人类用来判断某些对象或事件来自同一类别的方法，例如通过观察对象之间的相似程度。”约翰·保罗·穆勒
5.机器学习在行动
**作者:**彼得·哈灵顿
出版社 —曼宁出版公司
**难度等级:**初学者
在这里获取图书——亚马逊
《机器学习在行动》一书的封面
一本有价值的书，旨在给开发者机器学习所需技术的实践经验。对于熟悉与 ML 相关的 Python 代码片段来说，这是一本同样重要的书，尽管需要事先有 Python 的经验。
该书包含用于统计数据处理、数据分析和数据可视化的各种算法的代码，以及诸如分类、预测、建议、简化等任务。用最少的理论，这本书直接切入这些算法的实际实现。
6.模式识别和机器学习
**作者:**克里斯托弗·m·毕晓普
出版商 —施普林格
**难度等级:**中级
在这里获取图书——亚马逊
Github 回购:—https://github.com/ctgk/PRML
《模式识别与机器学习》一书的封面
针对有模式识别和机器学习的基本想法的个人，这本书假定读者在多元微积分和代数方面有某种程度的先验知识。
本书中的概念旨在解释 ML 领域中底层算法和技术的最新发展。涵盖广泛使用的主题，如贝叶斯方法，回归，分类，神经网络，图形模型，采样方法，等等，这本书非常适合理解 ML，统计，计算机视觉和挖掘。这本书配有大量练习和附加材料。
7.统计学习导论(R 语言应用)
作者:加雷斯·詹姆斯、丹妮拉·威滕、特雷弗·哈斯蒂和罗伯特·蒂布拉尼
出版商— 施普林格
**难度等级:**中级
在这里获取图书——亚马逊
《统计学习导论(R 语言应用)》封面
这本书，虽然需要一些线性回归的先验知识，却是理解统计学习概念的一个极好的工具。通过提供关于如何利用大型复杂数据集的平衡见解，它旨在教育广大统计人员和非统计人员，使他们能够理解手中的数据。
它涵盖了统计学习的几个重要概念，如线性回归，分类，基于树的模型，支持向量机，重采样方法，等等。各种例子和教程使学习过程更加愉快，它包括几个 R 实验室，演示这些统计方法的实施。
8.应用预测建模
**作者:**马克斯·库恩和杰尔·约翰逊
出版商— 施普林格
**难度等级:**中级
在这里获取图书——亚马逊
《应用预测模型》的封面
这本书被认为是许多预测建模概念的特别参考书，要求对统计学、R 编程语言和机器学习概念有很好的理解。作者着重解释数据收集、操作和转换过程，因为这在 ML 书籍中经常被忽略。
这本书的应用性质使它成为分析行业面临的实际问题的绝佳选择。读者可以深入数据预处理，分裂，模型调整，然后回归，分类，处理类不平衡，选择预测。
9.黑客的机器学习:案例研究和算法让你入门
**作者:**德鲁·康威&约翰·迈尔斯
出版商 —奥赖利媒体
**难度等级:**中级
在这里获取图书——亚马逊
《黑客的机器学习》一书的封面
正如标题所说，这本书不是给黑客看的，而是给那些对动手案例研究感兴趣的人看的。这本书需要很强的编程背景，旨在用驱动机器学习的算法来训练你。不同的章节集中于 ML 中的每个问题，例如分类、优化、预测和推荐。
这本书还训练你使用 R，以及如何分析数据集，并让你开始编写简单的 ML 算法。它不同于其他书籍的一个重要方面是它不太依赖数学来教授数学。
10.集体智慧编程:构建智能 Web 2.0 应用
**作者:**托比·塞格兰
出版商 —奥莱利传媒
**难度等级:**中级
在这里获取图书——亚马逊
《集体智慧编程》一书的封面
被许多人认为是机器学习的最佳指南，这本书更喜欢教你 ML 的实现，假设你知道 Python。它包括创建算法和程序的步骤，用于访问网站外的数据集，自己收集数据，以及分析和利用数据。
带你进入 ML 和统计，这本书包括爬虫，索引器，优化，PageRank 算法，过滤技术，决策树的例子。本书旨在引导你按照自己的节奏完成创建算法的整个过程，这本书做得很好。
11.统计学习的要素:数据挖掘、推理和预测
**作者:**特雷弗·哈斯蒂，罗伯特·蒂布拉尼，杰罗姆·弗里德曼
**难度:**专家
出版商 —施普林格
在这里获取图书——亚马逊
《统计学习的要素》的封面
这本书侧重于概念，而不是概念背后的数学。它收集了大量关于在几个部门实施统计学习的想法。充满了相关的例子和可视化，它应该是任何统计学家或数据挖掘爱好者的图书馆中必不可少的一块。
这本书涵盖监督和非监督学习，包括支持向量机，分类树，神经网络，助推，集成方法，图形模型，谱聚类，最小角度回归，路径算法等主题。
12.Python 机器学习
作者:塞巴斯蒂安·拉什卡和瓦伊德·米尔贾利利
出版者 — Packt
**难度:**专家
在这里获取图书——亚马逊
《Python 机器学习》一书的封面
假设你已经很好地理解了 Python 和机器学习的许多核心概念，这本书直接切入概念的实际实现。书中的概念包括 NumPy、Scikit-learn、TensorFlow2 和 SciPy 的最新解释。这本书通过从行业中面临的现实世界的挑战教你，为你承担现实世界的挑战做准备。它包括各种主题，如降维，集成学习，回归，聚类分析，神经网络，等等。
“最终，分类器的性能、计算能力以及预测能力在很大程度上取决于可用于学习的基础数据。训练机器学习算法所涉及的五个主要步骤可以总结如下:选择特征。选择绩效指标。选择分类器和优化算法。评估模型的性能。调整算法。”
― 塞巴斯蒂安·拉什卡， Python 机器学习
结论
在这个快速发展的时代，跟上这些进步并不断提升自己是当前的需要。有数百本关于机器学习和相关技术的书籍、指南和其他在线资源。机器学习一开始可能会令人吃惊，这就是为什么我们在本文中概述了十本最受欢迎的书籍，希望其中一些能引起你的兴趣。请随意推荐您认为可能对该列表有帮助的扩展。
注意:为了消除不同类型的问题，我想提醒你一个事实，这篇文章仅代表我想分享的个人观点，你有权不同意它。
更多有趣的阅读—
我希望这篇文章对你有用！以下是一些有趣的读物，希望你也喜欢
使用谷歌人工智能中心将想法变为现实
towardsdatascience.com](/top-google-ai-tools-for-everyone-60346ab7e08) [## 数据科学家的最佳数据科学工具
数据科学工具，使任务可以实现
towardsdatascience.com](/best-data-science-tools-for-data-scientists-75be64144a88) [## 2020 年的数据科学趋势
新十年的关键数据科学趋势
towardsdatascience.com](/data-science-trends-for-2020-9b2ee27af499) [## 数据科学如何助推网飞
当有效使用时，数据可以神奇的方式改变您的业务，并将它带到新的高度。
towardsdatascience.com](/how-data-science-is-boosting-netflix-785a1cba7e45)
关于作者
克莱尔丁。是Digitalogy**—**的内容制作者和营销人员，这是一个技术采购和定制匹配市场，根据全球各地的特定需求，将人们与预先筛选的&顶尖开发人员和设计师联系起来。在 Linkedin ， Twitter ， Instagram 上连接 Digitalogy 。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
