关于卷积神经网络的所有知识
克林特·王茂林在 Unsplash 上拍摄的照片
数据科学
理解卷积神经网络的概念及其在构建图像分类模型中的实现
“从计算机视觉的角度来看，毫无疑问，深度卷积神经网络是当今处理感知数据的‘主算法’。”
托马斯·马利西维茨
如今，我们都必须看到和使用各种图像效果和滤镜，以及我们的计算机和智能手机如何检测和识别照片和视频中的人脸。所有这些都可以通过“计算机视觉”来实现，而“计算机视觉”只不过是使用卷积神经网络的机器学习。
计算机视觉类似于人的视觉，它帮助系统识别、分类、检测数据中的复杂特征。它的一些应用可以在自动驾驶汽车、机器人视觉、面部识别中看到。
但是这种计算机视觉与我们人类的视觉并不完全相同，不像我们，计算机看到的图像是像素矩阵的形式。
图像是由像素组成的。并且每个像素值可以取从 0 到 255 的值。
什么是卷积神经网络
卷积神经网络或 CNN 是一种用于处理输入形状为 2D 矩阵形式(如图像)的数据的神经网络。
卷积神经网络的结构是具有若干隐藏层的前馈，主要是卷积和汇集层，随后是激活层。通过这个 CNN 模型，我们可以识别手写字母和人脸(取决于图像的层数和复杂程度)。
(图片由维基共享资源 ) 卷积神经网络模型
在本文中，我们将学习 CNN 的概念，并建立一个图像分类器模型，以便更好地掌握这个主题。
在建立模型之前，我们需要理解和学习卷积神经网络的一些重要概念。
- 众所周知，计算机将图像视为像素矩阵形式的数字。CNN 将图像视为三维对象，其中高度和宽度是前两个维度，颜色编码是第三个维度(例如，3x3x3 RGB 图像)。
现在想象一下，处理一幅 4K 图像(3840 x 2160 像素)的计算量会有多大。
盘旋
- 因此，卷积网络的主要目标是将图像简化为更容易处理的形式，同时保留特征并在预测时保持良好的准确性。
在卷积神经网络中有三个主要的重要单元，即输入图像、特征检测器和特征映射。
- 特征检测器是过滤器的核心(一个数字矩阵，通常是 3x3)。这里的想法是将图像的矩阵表示与核逐元素相乘，以获得特征图。在这个步骤中，图像的尺寸被减小，以便更快和更简单地处理。保留了图像的重要特征(如图像/对象特有的特征，即识别所必需的特征)。但是，在此步骤中会丢失一些功能。
(图片由维基共享 ) 卷积层——特征图
- 例如，如果我们有一个 5x5x1 维的输入图像，而我们应用于图像的卷积核/滤波器是 3x3x1 维的:
**Image matrix:**
1 1 0 1 1
1 0 1 0 1
1 1 1 1 0
0 0 1 1 0
1 1 0 0 0**Kernel matrix:** 1 0 1
0 1 0
1 1 0
那么核矩阵与图像矩阵的每个元素相乘后得到的卷积特征将是:
**Convolved matrix:**
3 5 3
3 2 5
4 4 2
这里，内核移动 9 次，因为步长为 1(即滤波器将在图像矩阵的每个元素后滑动)。
ReLu 激活功能
应用此 ReLu 函数(整流线性单元)的目的是增加模型中的非线性。因为图像/物体具有几个彼此非线性的特征。我们应用这个函数，以便我们的模型不会将图像分类视为线性问题。
汇集层
池层类似于卷积层，它负责减少卷积矩阵的大小。
(图片由 Wikimedia Commons ) 共享图层-要素地图
这是卷积神经网络过程中的一个重要步骤。汇集对于从图像中检测和提取显著特征是至关重要的，而不管不同的位置、角度、不同的光照等。同时保持训练模型的准确性和效率。
此外，随着图像数据的尺寸减小(同时保留主要特征)，处理数据所需的计算能力也降低。
有不同类型的池:最大池，最小池，平均池。
- 最大池从内核覆盖的特征映射矩阵部分提取最大值(具体池大小如 2x2)。
- Min pooling 从内核覆盖的特征映射矩阵部分提取最小值(具体池大小如 2x2)。
- 而平均池所有值的平均值是从内核覆盖的特征映射矩阵的部分中选择的(特定池大小如 2x2)。
最大池化是所有池化方法中最有效的(因为它将包含卷积特征图中最主要的特征)。
**Convolved matrix:**
3 5 4 1
2 2 5 6
4 4 2 5
1 3 5 4**Max pooled matrix:** 5 6
4 5**Min pooled matrix:** 2 1
1 2**Average pooled matrix:** 3 4
3 4
以上是汇集的要素地图。
根据输入图像的复杂程度以及必须提取的细节和特征的级别，可以增加或减少这些卷积层和池层的数量。但是请记住你在模型中增加的层数，所需的计算能力也会增加。
有了这些卷积和池层，我们的模型可以理解提取图像的特征。
展平
下一步是展平所获得的池特征图，即将多维池特征图矩阵转换成一维阵列(线性向量或列),以将其馈送到神经网络进行处理和分类。
全连接层—分类
在我们以列向量的形式获得我们的数据之后，我们将通过前馈神经网络传递它，在训练过程中，在每一次迭代中实现反向传播(提高预测的准确性)。
经过几个时期的训练，我们的模型将能够识别和区分图像的突出和低级特征。
从神经网络获得的最终输出值的总和可能不等于 1，但是有必要使这些值介于 0 和 1 之间。这将表示每个类别的概率，并进一步使用 **softmax 技术(用于多类别分类的激活函数)**对它们进行分类。
利用 MNIST 数据集实现 CNN
在本文中，我们将使用 MNIST 数据集，即一个由 70，000 张 (60，000 张训练图像和 10，000 张测试图像)0 到 9 之间的手写单数字的小正方形 28×28 像素灰度图像组成的数据集。
这里我们模型的目标是将一组给定的手写数字图像分类为 1 到 10 (代表从 0 到 9 的整数)。
我们将在本文中使用 Keras 和 matplotlib 库。
以下代码将使用 Keras API 加载 MNIST 数据集的前九幅图像，并使用 matplotlib 库绘制这些图像。
from keras.utils import to_categorical
from keras.models import Sequential
from keras.layers import Conv2D
from keras.layers import MaxPooling2D
from keras.layers import Dense
from keras.layers import Flatten
from keras.optimizers import SGD
from keras.datasets import mnist
from matplotlib import pyplot
# load dataset
(trainX, trainy), (testX, testy) = mnist.load_data()# plot first 9 images
for i in range(9):
pyplot.subplot(330 + 1 + i)
pyplot.imshow(trainX[i], cmap=pyplot.get_cmap('gray'))**pyplot.show()**
训练和测试图像(已经被模型很好地定义了)被分别加载，如上面的代码所示。
(图片由作者提供)MNIST 数据集中的第个九位手写数字图片
现在，我们将加载完整的数据集，并在将数据输入神经网络之前对其进行预处理。
(trainX, trainY), (testX, testY) = **mnist.load_data()**trainX = trainX.**reshape**((**trainX.shape**[0], 28, 28, 1))
testX = testX.**reshape**((**testX.shape**[0], 28, 28, 1))trainY = **to_categorical(trainY)**
testY = **to_categorical(testY)**
在上面的代码中，我们对数据进行了整形，使其具有单一的颜色通道(因为图像具有相同的 28x28 像素和灰度形式)。
此外，我们有一个热编码的数据集值(使用to_categorical，一个 Keras 函数)，因为我们知道有 10 个不同的类都由唯一的整数表示。这里，每个整数样本都被转换为一个十元素的二进制向量，其中 1 表示类值的索引，0 表示所有其他类的值。
完成此操作后，我们将不得不对数据集进行归一化，因为我们知道图像的像素值在 0 和 255(黑白)之间变化。为此，我们将该数据缩放至范围【0，1】。
trainX = trainX.**astype('float32')**
testX = testX.**astype('float32')**trainX = **trainX / 255.0**
testX = **testX / 255.0**
在上面的代码中，我们首先将 pixel 的整数值转换为浮点数。之后，我们将这些值除以最大数(即 255)，这样所有的值都将在[0，1]的范围内缩放。
现在我们将开始构建我们的神经网络。
model = Sequential()
model.add(**Conv2D(32, (3, 3), activation='relu',
kernel_initializer='he_uniform', input_shape=(28, 28, 1))**)
model.add(**MaxPooling2D((2, 2))**)
model.add(**Flatten**())
model.add(Dense(100, activation='relu',
kernel_initializer='he_uniform'))
model.add(Dense(10, **activation='softmax'**)) opt = SGD(lr=0.01, momentum=0.9)
model.compile(optimizer=opt, loss='categorical_crossentropy',metrics=['accuracy'])
在上面的代码中，我们使用了用于逐层创建模型的Keras API sequentaial()。之后，我们为我们的模型添加了一个卷积层，内核大小为 3x3，有 32 个过滤器。接下来是内核大小(2x2)的单个MaxPooling()层。然后输出特征图被展平。
由于我们知道有 10 个类，所以在输出层中需要 10 个节点用于每个类的预测(多类分类)以及 softmax 激活函数。在特征提取层和输出层之间，我们添加了一个具有 100 个节点的密集层，用于模型的特征分析和解释。
模型中使用了**Stochastic gradient descent**(学习率为 0.01，动量为 0.9) 优化器和**categorical_crossentropy** 损失函数(适用于多类分类模型)。
最后，在编译我们的模型之后，需要在训练数据集上对它进行训练，在测试数据集上对它进行测试，并进一步评估它的结果(即准确性和损失)。
batch_size = 128
num_epoch = 10
#model training
model_log = **model.fit(trainX, trainY,
batch_size=batch_size,
epochs=num_epoch,
verbose=1,
validation_data=(testX, testY))**
在上面的代码中，我们使用了 10 个epochs和 128 个batch_size(批量大小是一次迭代中训练的样本数)。下面是模型的训练输出:
(图片由作者)CNN 模型的训练输出
上述结果可以根据性能进行评估:
**score = model.evaluate(testX, testY, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])**
(图片由作者)CNN 模型的训练输出
测试准确度> 98%时，我们可以说我们的模型在准确预测方面训练有素。您也可以使用matplotlib库来可视化这些结果！
结论
我希望通过这篇文章，你能够理解和掌握卷积神经网络的概念。
为了更好地理解这些概念，我建议您尝试编写这些代码。继续探索，我相信你会发现新的特性。
如果你有任何问题或意见，请发表在评论区。
查看完整的数据可视化指南:
最初发表于:www.patataeater.blogspot.com
你想知道的关于 Python 中决策树的一切
从基本原则到生产环境中的部署，包括工作示例和易于理解的解释
沙哈达特·拉赫曼在 Unsplash 上拍摄的照片
介绍
我在各种媒体上看到了许多关于 Python 中决策树机器学习算法的文章，但它们总是让我想要更多。
它们要么看起来在过程中中途跳跃，要么当我将代码应用到我的数据时它不工作，或者它们忽略了过程中的重要部分。
由于我找不到完全符合要求的东西，所以我想我自己也要试一试，这就产生了写这篇文章的想法。
背景
如果有人需要关于如何使用决策树来预测数据中的分类的介绍或复习，那么 R2D3 的这篇优秀文章提供了关于它如何工作的一步一步的可视化，绝对精彩！
【http://www.r2d3.us/visual-intro-to-machine-learning-part-1/
如果你想加深你的理解，包括一些数学知识和熵是如何工作的，那么福斯特·普洛沃斯和汤姆·福西特的这本书是一个主要书籍，它以一种简单易懂的方式解释了更复杂的主题
https://www . Amazon . co . uk/Data-Science-Business-Data-analytic-thinking/DP/1449361323
除了这些资源，还有大量关于 https://towardsdatascience.com/和 https://medium.com/的进一步阅读。
入门指南
有相当多的外部库涉及到决策树模型的开发和可视化，所以让我们从导入它们并设置几个配置参数开始…
导入和塑造数据
我选择处理的数据集是 UCI 机器学习库中的红酒和白酒数据集。这是一个非常好的数据集，因为我们可以查看代表葡萄酒的数据，然后训练决策树模型来预测葡萄酒是白还是红。
数据集可以在这里找到…https://archive.ics.uci.edu/ml/datasets/wine+quality
…这是符合 https://archive.ics.uci.edu/ml/citation_policy.htmlUCO 引文政策的参考文献…
Dua d .和 Graff c .(2019 年)。UCI 机器学习资源库【http://archive.ics.uci.edu/ml】。加州欧文:加州大学信息与计算机科学学院
首先，我们将读取来自两个不同的逗号分隔文件中的红葡萄酒和白葡萄酒数据，设置一个标签或目标变量 1 =红，0 =白，然后从这两个源生成一个单独的DataFrame,并查看数据…
作者图片
接下来，我们将看看数据集中白葡萄酒和红葡萄酒的相对数量…
0 0.753886
1 0.246114
Name: label, dtype: float64
所以我们的葡萄酒含 75.4%的白葡萄酒和 24.6%的红葡萄酒。根据对超市货架的一瞥，这听起来似乎是正确的，但为了我们的决策树机器学习算法的目的，它需要重新塑造，该算法将预测葡萄酒的颜色(红色或白色)。
对于这些类型的算法来说，目标变量的命题需要被平衡，我们的是 75.4% / 24.6%。
一种常见的技术是“下采样”,其中较小的部分被全部使用，而来自较大数据集的相同数量的数据点被随机采样。
在下面的代码中，我们简单地抽取所有的红葡萄酒，然后随机抽取白葡萄酒来匹配红葡萄酒的数量…
作者图片
让我们再检查一下比例，确保我们达到了平衡…
1 0.5
0 0.5
Name: label, dtype: float64
将数据分成训练和测试数据集
下一个代码块复制了所有的“特征”(酸度、氯化物等。)转换为 X，将“目标”变量(标签为红/白)转换为 y。
然后，它将 X 和 y 分成训练和测试数据。训练数据将用于训练模型，测试数据将用于评估模型。
这种分离的原因是将测试数据排除在训练之外，以便模型避免“过拟合陷阱”，即模型对训练数据表现良好，但对从未见过的新数据表现不佳。
开始了…
调整模型
在我们继续创建决策树模型之前，我们需要根据与我们的红葡萄酒和白葡萄酒数据最匹配的值来调整“超参数”，也就是说，我们需要为模型选择参数，使其在进行预测时具有最高的准确性。
如果我们手动这样做，我们可以不断调整设置，重新运行模型和分数，但这非常耗时，也不太科学。
相反，我们可以使用方便的sklearn.model_selection.GridSearchCV函数，该函数将尝试我们传递给它的所有超参数组合，并让我们知道哪些是最有效的。
我将它封装在dtree_grid_search函数中，该函数接受一个包含所有特性的X参数、一个包含所有标签的y参数和一个表示应该使用多少 X 和 y 数据分割来测试超参数的nfolds。
它在这里…
作者图片
创建决策树模型
我们可以看到网格搜索确定为“最佳”或“最准确”的参数，包括criterion = 'entrophy'、max_features='auto'等。
请注意，我选择了max_depth=3,而不是优化值 9，以减少树中的级别数，从而更容易为本文的目的可视化。
我有意识地选择牺牲准确性(在 9 个级别上，准确性约为 93%,而不是 95%)来换取简单性和可读性，这是一件完全有效的事情，事实证明，模型设计师在现实世界中构建模型时一直在进行这些权衡。
下一个代码块使用优化的超参数构建我们的决策树模型，使用训练数据训练模型，然后使用训练数据对我们模型的有效性进行评分，结论是我们的决策树模型可以基于葡萄酒特征值预测目标葡萄酒颜色，准确率为 92.8% …
0.9275
特征重要性
花两行代码来快速了解这些特性的相对重要性是值得的…
作者图片
原来total sulfur dioxide是最重要的特征，重要性为 0.6。volatile acidity和chlorides分别以 0.19 和 0.17 紧随其后。在此之下，其余特征的重要性得分较低。
这向我们展示了哪些特征影响了模型，并且可能需要去掉chlorides下面的特征并重新运行模型。如果精确度的损失可以忽略不计，但是复杂度的降低是显著的，那么移除它们可能是一个很好的折衷。
此外，即使我们拒绝我们的决策树，并探索不同的机器学习算法，如逻辑回归，关于哪些特征有影响的信息仍然会有用。
可视化决策树
将决策树转化为直观的可视化表示是帮助我们理解它如何工作以及它在做什么的关键一步。
有很多可视化决策树的库，这里我展示了一些我最喜欢的。
我从dtreeviz开始，它可以通过运行下面的命令行来安装
pip install dtreeviz
…您可以在此查看完整文档—https://github.com/parrt/dtreeviz
我已经在网上找到了许多绘制 Seaborn 包附带的企鹅数据集的例子，但我很难找到任何有助于我在自己的数据帧上使用它的例子。
玩了一会儿之后，我想出了下面的代码，它可以在任何 X 特征DataFrame和 y 目标Series上工作。
在我看来,dtreeviz不仅提供了模型的视觉效果，还提供了特征的分布，以及算法如何做出分叉树和划分数据的决定
作者图片
这个dtreeviz真的很美是不是！从顶部读取决策树机器学习算法选择基于total sulfur dioxide less than 74.50进行第一次数据拆分。
这导致了我们在第二行中看到的数据分裂，我们可以很容易地看到和理解剩余的分裂，直到算法在深度为 3 时结束，其中 3 组被分类为白葡萄酒，5 组被分类为白葡萄酒。
然而，尽管dtreeviz在视觉上令人惊叹，但一些已经存在了一段时间的树可视化库中却缺少一些信息。
例如graphviz虽然在视觉上不那么吸引人，但确实包含了关于每个节点熵(即杂质)的附加信息，以及每个节点中出现的每个目标变量(红葡萄酒和白葡萄酒)的数量。
因此，我的偏好是使用两个库和两个版本的树可视化，我发现这有助于我完全理解模型在做什么。
请注意，我在下面添加了几行额外的代码，将树图像写出到一个.png文件中，然后再读回来。在这里，完全可以显示树，而不用用更少的代码行保存它，除非保存它，否则不可能控制比例，并且默认比例太大，不容易查看，因此我选择将其写入文件…
作者图片
使用模型进行预测
当我第一次学习决策树时，我想知道如何使用该模型对一组新数据进行预测，我努力在网上找到答案。
如果我只有一瓶我想预测颜色的葡萄酒，该怎么办？我会怎么做？
事实证明这相当简单，下面的函数将获取一组葡萄酒数据，进行预测，然后返回结果…
下面的两行代码只是从完整的数据集中挑选顶部和底部的数据行，这样我们就可以运行一个预测，看看它是否与实际标签相匹配…
作者图片
作者图片
我们走吧。我们使用第一行和最后一行的值调用单个预测函数，我们可以看到，在每种情况下，预测都与实际标签匹配(1=“红色”，0=“白色”)，这就是我们使用模型进行单个预测所需要知道的全部信息。
('red', 'white')
我们可能想做的另一件事是对整个文件或整个DataFrame进行预测，结果证明这也非常容易。
下面的代码将 X_test 和 y_test 数据放在一起，显示带有实际标签的数据集，然后调用模型对每一行进行预测。
然后它显示数据，我们可以看到实际标签和预测标签并排。
作者图片
我们还可以使用两种略有不同的方法来验证我们的模型的准确性。
第一个是将那些label与predicted_label匹配的行表示为行数的百分比，这给出了 92.3%的准确度。
然后运行model.score,这正好显示了这个库函数做了什么以及它是如何工作的。它只是计算实际值和预测值匹配的行的百分比…
(0.9275, 0.9275)
在生产环境中部署和实现决策树
一旦所有数据科学工作结束，就不可避免地需要在生产环境中实施，而该环境可能不是 Python，并且可能无法访问我们在本例中使用的所有专业建模库。
树形可视化让我们了解了算法正在做什么，但幸运的是，最简单的可视化技术——文本表示——以一种可以直接翻译成一系列if else语句的格式显示树形图，这些语句可以很容易地用任何编程语言进行编码。
在我的环境中，生产系统是用 C#或 VB 脚本编写的，因此能够执行这最后一步以“操作化”所有数据科学工作至关重要。
sklearn.tree.export_text方法可以用来给我们的模型一个非常有用的表示…
作者图片
这个输出可以很容易地转换成一个函数，这个函数可以很容易地用 C#、VB 脚本、Java 或任何其他编程语言编写…
最后，我们在下面测试了操作化函数，以验证标签的预测方式与使用上面的单行或整个数据帧方法完全相同…
('red', 'white')
结论
我们从一些在线资源开始，这些资源解释了决策树在提取和形成公共数据集之前如何从基本原则开始工作。
然后，我们将数据分为训练和测试两部分，创建了一个优化的决策树模型，将我们的数据拟合到该模型中，并评估该模型的准确性。
然后，我们使用两个不同的强大库来可视化我们的决策树，并对单个案例和整个数据文件进行预测。
最后，我们展示了如何将决策树模型转换为 if-then-else 算法，该算法可以轻松部署到生产环境中，即使该环境使用不同的编程语言(例如 C#)。NET、VBScript、Java 等。
完整的源代码可以在这里找到:
https://github.com/grahamharrison68/Public-Github/tree/master/Decision Trees
关于 Python 中的字典，你需要知道的一切
Python — 30 天挑战
在本文中，我们将从基础开始，深入探究字典在 Python 中能做的一切
Python 中的字典或其他编程语言中的哈希表是存储和检索值的最有效的数据结构之一。它们根据一个键存储每个值，形成一个键-值对。在本文中，我们将学习开始使用 Python 时应该知道的关于字典的一切。
图片来自像素
以下是我们今天将要讨论的关于字典的话题列表:
- 字典介绍
- 如何定义字典
- 如何使用字典
- 如何在字典中赋值
- 词典研究方法
- 对字典键/值的限制
- 结论
这是我 30 天文章写作挑战的一部分。请随意查看我的新人帖子上的文章:
https://nouman10.medium.com/lets-publish-30-articles-in-30-days-a0b8111855bb
字典介绍:
Dictionary 是 Python 中的一种复合数据结构，基本上由一系列键值对组成。键值对中的每个键都将该键映射到其关联值。
如何定义字典:
在 Python 中，字典通常由一列用大括号({})括起来的逗号分隔的键值对来定义。每个键都用冒号(:)与其关联的值隔开。
以下代码片段构建了一个足球运动员及其相关俱乐部的字典:
football_players_club = {
"Cristiano Ronaldo": "Juventus",
"Bruno Fernandes": "Manchester United",
"Lionel Messi": "Barcelona",
"Sadio Mane": "Liverpool",
"Harry Kane": "Tottenham Hotspur"
}
还可以通过使用字典的构造函数dict()来定义字典。它可以接受一组键值对。因此，包含键-值对元组的列表是通过构造函数构造字典的有效方式，包含键-值对列表的元组也是如此。
作者图片
尽管可以像显示列表一样显示词典，但不能使用数字索引来访问它们。字典中没有顺序，你只能使用它的键来访问一个值。使用索引会导致一个KeyError。
如何访问字典值:
为了访问字典值，我们使用与值相关联的键。例如，要访问上面字典中的“巴塞罗那”和“利物浦”,我们使用:
print(football_players_club["Lionel Messi"])
print(football_players_club["Sadio Mane"])
作者图片
使用字典中不存在的键会导致一个KeyError:
football_players_club['Muhammad Salah']
football_players_club[1]
这两种情况都会导致以下错误:
作者提供的图片
请注意，尽管我们在第二个示例中使用了数字索引，但两者的误差是相同的。这是因为 Python 认为您在方括号内传递的任何内容都是字典的键。事实上，Python 实际上允许字典有如下的数字键:
numerical_keys = {
1: 'a',
0: 'b',
4: 'c'
}numerical_keys[0]
作者图片
当我们使用“0”作为键时，我们不是说获取索引为 0 的值，而是将 0 作为键的值，这就是预期的“b”。
如何在字典中赋值:
我们可以为一个键指定新的值，甚至更新字典中现有键的值，只需简单地用这个键访问字典并将其设置为所需的值，如下所示:
football_players_club['Luis Suarez'] = 'Athletico Madrid'
football_players_club['Harry Kane'] = 'Manchester City'
词典方法:
词典的常用方法:
在这里，我们将研究 python 中应用于词典的一些常用方法，最后，我们将看到所有这些方法的演示:
注意:*dict* 、 *dict_1* 、 *dict_2* 都代表某种任意的字典。
len:
顾名思义，它返回字典中键值对的长度。
语法:len(*dict)*
在:
它允许我们检查一个键是否存在于字典中
语法:key in *dict*
我们可以利用这一点来避免访问字典中不存在的键。例如，如果关键字不在字典中，使用dict[key]将引发一个KeyError，但是使用下面一行代码不会，因为 python 短路评估将阻止它评估and语句的第二部分，以防key in *dict* 返回 false。
key in *dict* and *dict*[key]
获取:
它获取与给定键相关联的值。它还接受一个可选的默认参数，如果字典中没有这个键，就会返回这个参数。但是，如果键不存在，并且也没有传递默认值，则该函数返回 None。
语法:*dict*.get(key)或*dict*.get(key, default_value)
按键:
它返回字典的键
语法:*dict*.keys()
价值观:
它返回字典的值
语法:*dict*.values()
项目:
它将字典中的条目作为一个键值元组序列返回。
语法:*dict*.items()
注意:在字典中使用 for 循环会在每次迭代时返回键，即for key in *dict* 将遍历字典中的键列表
popitem:
它从字典中删除最后一个键-值对并返回它。
语法:*dict*.popitem()
流行音乐:
它移除与给定键关联的键-值对。它还接受一个可选的默认参数，如果字典中没有这个键，就会返回这个参数。但是，如果键不存在并且默认值也没有被传递，那么该函数会引发一个KeyError.
语法:*dict*.pop(key)或*dict*.pop(key, default_value)
清除:
顾名思义，它清除字典(清空字典)
语法:*dict*.clear()
更新:
它将一个字典与另一个字典或一个键值对的 iterable 合并，就像我们在定义字典一节中看到的那样。两个字典中的所有键值对都被添加到第一个字典中。如果一个关键字已经存在于第一个字典中，则它的值由第二个字典中与该关键字相关联的值来更新。如果一个关键字不在第一个字典中
语法:*dict_1*.update(*dict_2*)(注意:只有*dict_1*被更新)
演示:
作者图片
对字典键/值的限制:
字典键:
正如我们之前看到的，您可以将字符串和整数设置为字典值中的键。您甚至可以像这样将 Python 中的内置对象设置为键:
dictionary = { int: 8, float: 9 }
dictionary[str] = 10
print(dictionary)
作者图片
然而，也有一些规则。给定的键在字典中只能出现一次，也就是说，每次试图为字典中已经存储的键设置值时，都会覆盖以前的值。最新的是存储的值。
此外，您只能使用不可变类型作为键。这意味着元组是一个非常好的键，而列表则不是。
dictionary = {(1, 1): 'a', (1, 2): 'b', (2, 1): 'c', (2, 2): 'd'}
print(dictionary)
这运行得很好，但是下面给出了一个错误:
dictionary = {[1, 1]: 'a'}
print(dictionary)
作者图片
字典值:
另一方面，字典值没有任何限制。任何值都是合适的字典值，不管它是可变的还是不可变的，是内置的还是用户定义的。字典值也可以重复，次数不限。
结论:
总结一下:
- 我们从 Python 中字典的基本介绍开始，包括定义、访问和赋值
- 然后我们研究了字典的一些内置方法
- 最后，我们研究了字典键和值的限制。
如果您觉得以上内容对您有用，请分享并随时支持我–>
关于 Python 中的函数，你需要知道的一切
Python — 30 天挑战
在本文中，我们将从基础开始，深入探究使用 Python 中的函数可以做的一切
函数是任何编程语言中模块的基本构建块，是理想情况下执行单一任务的单一自包含代码块。本文为初学者提供了一种从 Python 中的函数开始的友好方式。我们将在这篇文章中讨论很多关于函数的内容，所以让我们开始吧！！
图片来自像素
以下是我们将讨论的函数主题列表:
- 在 Python 中定义您的第一个函数
- Python 中的参数
- 位置参数
- 关键字参数
- 默认参数
- 可变长度位置参数
- 可变长度关键字参数
- 结论
这是我 30 天文章写作挑战的一部分。请随意查看我的新人帖子上的文章:
https://nouman10.medium.com/lets-publish-30-articles-in-30-days-a0b8111855bb
在 Python 中定义您的第一个函数
让我们从定义第一个函数开始，这个函数完成将“Hello，world”打印到屏幕上的简单任务。
def print_hello_world():
print("Hello, world")print_hello_world()
让我们来分解一下:
- 我们首先告诉解释器我们正在使用关键字
def定义一个函数 - 然后是函数的名字，在我们的例子中是
print_hello_world。你可以随心所欲地定义它 - 然后是两个圆括号。目前，它们是空的，但是它们包含了您想要传递给函数的任何参数(下一节将详细介绍)
- 然后是一个缩进的代码块，包含函数中要执行的代码。在我们的例子中，它只是打印“Hello，world”。
- 到目前为止，我们已经定义了我们的功能。它不会打印任何东西，除非我们在最后调用它。
- 类似地，我们可以调用该函数 10 次，它将打印 10 次“Hello，world ”,但定义将只编写一次。这就是功能在可用性方面的力量
注意，一个函数通常也有一个 return 语句。这是函数返回的值，可以按照您的意愿存储。
函数中的参数
参数是可以传递给函数的值，这些值将决定函数的执行方式。我们可以通过不同的方式传递参数:
位置参数:
传递参数最常见的方式是调用一个函数，并在与函数定义相同的位置传递参数。让我们以除法函数为例:
def integer_division(num_1, num_2):
return num_1 // num_2
如果我们想将数字 10 除以数字 2，我们需要调用如下函数:
integer_division(10, 2)
这会返回 5。但是如果我们像这样改变位置:
integer_division(2, 10)
那么函数将返回 0，所以在传递位置参数时位置是很重要的。注意，我们需要在这里传递两个必需的参数，否则我们将得到一个TypeError,表明我们传递了不正确数量的参数
关键词参数:
我们也可以在调用函数时以key=value格式传递参数。这意味着我们不需要记住顺序。考虑与上面相同的函数:
def integer_division(num_1, num_2):
return num_1 // num_2
我们可以像这样使用关键字参数来调用它:
integer_division(num_1=10, num_2=2)
或者像这样:
integer_division(num_2=2, num_1=10)
这两个都将返回 5。我们也可以传递位置参数和关键字参数的组合。但条件是关键字参数将出现在所有位置参数之后，如下所示:
integer_division(10, num_2=2)
这是必需的，以便 Python 解释器能够理解序列并为每个参数分配正确的值
默认参数:
Python 也允许我们在定义函数时定义默认参数。我们可以在函数定义期间这样定义它们:
def integer_division(num_1=12, num_2=2):
return num_1 // num_2
现在我们可以如下调用该函数:
integer_division()
这将返回 6，但我们也可以传递自定义值(所有都是有效的选择):
integer_division(10) -> returns 5
integer_division(12, 3) -> returns 4
integer_division(num_2=4) -> returns 3
integer_division(10, num_2=5) -> returns 5
**注意:**当你将一个可变对象(比如一个列表)作为默认参数传递给一个函数时，默认参数有一个常见的问题。考虑以下函数:
def append_item(a_list=[]):
a_list.append('item')
print(a_list)
您可以使用列表调用如下函数:
append_item(['item_1'])
作者图片
append_item(['item_2'])
作者图片
这是意料之中的。每当一个新的列表被创建，我们添加一个项目到它。但是让我们看看当我们使用默认参数时会发生什么:
append_item()
append_item()
append_item()
作者图片
震惊吧？我也是。！。它应该每次只打印一个项目的列表。
这背后的原因是，默认参数在函数定义时创建一次，并存储在内存中。这就是为什么使用可变对象会修改内存中的对象，并可能导致一些意想不到的结果。实现此功能的更好方法如下:
def append_item(a_list=None):
if a_list is None:
a_list = []
a_list.append('item')
print(a_list)
这将确保每次使用默认参数时都创建一个新的空列表。
可变长度位置参数(*args):
你可能以前见过这个(*args)，但不知道它是什么意思。当我们不知道要传递的参数的确切数量，但需要以类似的方式处理它们时，就使用这种方法。
例如，你想写一个函数来增加一些数字。你事先不知道你要加多少个数。在这种情况下这很方便:
def add(*args):
total = 0
for num in args:
total += num
return total
当您使用这种语法时，args基本上是所有位置参数值的元组。让我们调用这个函数:
add(1, 2, 3, 4, 5)
这将像预期的那样返回 15。我们甚至可以打印元组并自己检查。另外，args这个名字不是必须的，你可以随意定义，但是要加一个星号(*)。
def add(*list_of_numbers):
total = 0
print(list_of_numbers)
for num in list_of_numbers:
total += num return total
作者图片
可变长度关键字参数(**kwargs):
我们还可以传递任意数量的关键字参数，函数将接收这些参数作为一个字典，从中我们可以提取我们想要的值:
def print_kwargs(**kwargs):
print(kwargs)
我们可以用多种方式调用这个函数:
print_kwargs(num_1=10, num_2=5, num_3=1)
作者图片
print_kwargs(name='Nouman', age='23', profession='Software Engineer')
作者图片
结论:
总结一下:
- 我们从用 Python 编写第一个函数开始
- 然后我们研究了位置和关键字参数
- 最后，我们研究了缺省参数和可变长度参数
如果您觉得以上内容对您有用，请分享并随时支持我–>
关于梯度下降你需要知道的一切
第 1 部分—详细解释算法
梯度下降是一种使用一阶迭代来解决优化问题的算法。由于梯度下降被设计成寻找微分函数的局部最小值，所以梯度下降被广泛用于机器学习模型中，以寻找使模型的成本函数最小化的最佳参数。本文将详细讨论梯度下降算法，下一篇文章将讨论它在线性回归模型中的应用。
算法
如上所述，梯度下降解决最小化问题，假设我们有一个优化问题:
我们想找出使函数 J(θ_0，θ_1)最小的正确参数θ_0 和θ_1。如果函数 J(。)是可微的，我们既可以基于微积分求解一阶条件，也可以使用梯度下降找到正确的θs，如果使用微积分，我们知道需要求解:
一阶条件
直觉是，函数的“斜率”在最优点将是水平的。如果函数是凸的，它将是最小值。下图说明了只有一个参数的函数的一阶条件。
求解最小值
尽管这种分析方法执行最小化而无需迭代，但它通常不用于机器学习模型。当参数数目太大时，效率不够高，并且如果函数太复杂，有时我们不能容易地求解一阶条件。因此，对于具有众多特征的模型，我们通常使用梯度下降算法来最小化成本函数。为了找到使 J(θ_0，θ_1)最小的θ_0 和θ_1，梯度下降操作如下:
- 1，对θ_0 和θ_1 进行初步猜测
- 2、检查最初猜测时的偏导数。偏导数在梯度下降中称为梯度:
偏导数给出了方向
- 3、基于偏导数和学习率𝛂:同时更新θ_0 和θ_1
右边的θ是旧值，而左边的θ是更新值
- 4、重复第 2 步和第 3 步，直到 J(θ_0，θ_1)不再显著下降。该算法输出使 J(θ_0，θ_1)最小的估计θ_0 和θ_1。
在下面的部分，我将解释为什么这个算法找到最小点，进行初步猜测，并选择正确的学习率。
为什么有效？
梯度下降的关键直觉是，从每一步到最小点，它采取最快的路线快速收敛。这是通过在每一步取偏导数来找到局部最小值的方向。下图解释了只有一个参数的函数的直觉。左侧面板显示了初始猜测位于最佳点左侧的时间。因为函数 J(。)是凸的，初始猜测的导数将是负的(初始点的斜率将是负的)。因此，我们需要增加θ，以达到局部最小值θ*。再看更新函数，由于 dJ(θ)/dθ为负，θ-𝛂dJ(θ)/dθ会大于θ，从而向局部极小值θ移动。右图显示了当初始猜测位于局部最小值θ的右侧时的相反情况。由于 dJ(θ)/dθ为正，θ-𝛂dJ(θ)/dθ将小于θ，从而向θ*移动。
梯度下降如何向θ*方向更新
你可能会注意到，当提到函数的最小点时，我使用局部最小值而不是全局最小值。这是因为梯度下降只能找到局部最小值。如果一个函数有多个局部极小值和一个全局极小值，不保证梯度下降会找到全局极小值。此外，它找到哪个局部最小值将取决于初始猜测的位置。以下图为例。b 是全局最小值，而 A 和 C 是 J(θ)的局部最小值。如果初始猜测位于区域 A 或区域 C，梯度下降将在局部最小值 A 或 C 处取最优θ。只有当初始猜测位于区域 B 时，算法才会找到使 J(θ)达到全局最小值 B 的最优θ。
局部最小值与全局最小值
如何进行初步猜测？
如上所述，进行初步猜测对于找到正确的最小值非常重要。从上图可以看出，C 点是一个局部极小值，它可能不能很好的代表 J(θ)的极小点。因此，如您所见，在大多数情况下，0 可能不是一个好的初始猜测。实际上，最初的猜测通常是通过应用随机函数来完成的。它可以是基于所有θ可能值范围内的均匀分布的随机函数。如果可能的话，您可以用不同的初始猜测运行算法，并比较 J(θ),以查看它们彼此之间是否有显著差异。
什么是好的学习率？
学习率𝛂在整个过程中是一个常数，它定义了算法更新的速度。使用正确的𝛂是有效运行梯度下降的关键。如下图所示，如果𝛂太小，算法就会太慢而无法收敛，因为它需要很多步骤。如果𝛂太大，它可能“跳过”局部最小值，有时甚至可能不收敛。实际上，对于大多数情况，0.01 是一个很好的学习率。
左:𝛂太小；右:𝛂太大
批量梯度下降和随机梯度下降
我们拥有的数据点越多，在训练机器学习模型时，我们给算法带来的计算负担就越大。在梯度下降的更新步骤中，我们可以在计算偏导数时取全部训练样本或部分训练样本。前者称为批量梯度下降，后者称为随机梯度下降。批量梯度下降更准确地找到正确的局部最小值。但是，如果训练样本很大，就太慢了。随机梯度下降仅单独考虑每个训练观察。它不是计算成本函数的精确偏导数，而是使用每个观察值来估计偏导数，然后在该方向上迈出一步。虽然每个观察将提供真实偏导数的差的估计，但是给定足够的随机性，参数将以快得多的速度收敛到良好的全局估计。此外，由于它只需要考虑一个单一的观察，随机梯度下降可以处理数据集太大，不适合在内存中。
本文详细解释了梯度下降算法。具体来说，它比较梯度下降和一阶条件来解决优化问题；梯度下降怎么操作，为什么有效；如何做好初始猜测，找到好的学习率；批量下降和随机梯度下降有什么区别？在下一篇文章中，我将讨论梯度下降在线性回归模型中的应用。
感谢您阅读这篇文章。这是我所有博客帖子的列表。如果你感兴趣的话，可以去看看！
https://zzhu17.medium.com/my-blog-posts-gallery-ac6e01fe5cc3 https://zzhu17.medium.com/membership
关于 Python 中的索引，您需要知道的一切
Python 中不同数据类型和结构的索引概述。
(src =https://pixabay.com/images/id-1690423/
介绍
在通用编程中，使用数据结构是很常见的。数据结构是由更小的数据类型组成的类型。数据结构的一个例子是列表或字典。数据结构允许我们方便地将几个组件作为同一个一致变量的成员进行组织和工作。正如您所想象的，这使得数据结构成为数据科学中非常重要的组成部分。假设数据结构是由更小的组件组成的，那么肯定有一种方法可以基于某些特性来访问各个组件。为此，我们使用索引。
索引很重要，因为它允许我们毫不费力地调用数据结构的一部分，以便单独处理结构内部的组件。当然，对于数据科学来说，掌握这一点是非常重要的，因为数据科学家可能会经常使用数据结构。
索引类型
在我们开始使用索引之前，让我们看看哪些类型实际上可以被索引。在 Python 编程语言中，可以使用给定类中的 getitem()方法对类型进行索引。这意味着我们可以将索引方法应用于任何类型，只需简单地添加这个方法，并返回准确的结果。为了尝试这一点，我们将首先创建一个类。考虑下面的例子:
class Winners: def __init__(self, first, second, third): self.first, self.second = first, second self.third = third
现在我们可以将 getitem()方法添加到这个新类中。这将增加使用简单索引从类中轻松获取我们的位置的能力。
def __getitem__(self, x):
对于这个例子，我认为最好的攻击方法是在初始化这个类的构造函数时创建一个字典。使用这种方法，我们将能够简单地调用基于数字的字典索引，以便接收这场比赛的位置。
class Winners: def __init__(self, first, second, third): self.first, self.second = first, second self.third = third self.index = dict({1 : self.first, 2 : self.second, 3 : self.third})
最后，我们将结束 getitem()方法，只需用提供的数字调用字典键:
class Winners: def __init__(self, first, second, third): self.first, self.second = first, second self.third = third self.index = dict({1 : self.first, 2 : self.second, 3 : self.third}) def __getitem__(self, x): return(self.index[x])
虽然这当然很好，但是让我们记住，我们只是这里的日志赢家，所以任何超过 4 点的人都不包含在这个类中。记住，如果我们在这个类上调用索引 4，我们将得到一个 KeyError 作为回报。每当我们创建软件时，尤其是在我们的软件用户可能永远不会看到的类中，我们会希望抛出一些错误，使错误比这更明显一些。考虑到这一点，我们将在这个方法中添加一个 try 和 catch，以便打印出更详细的错误。最终结果看起来有点像这样:
class Winners: def __init__(self, first, second, third): self.first, self.second = first, second self.third = third self.index = dict({1 : self.first, 2 : self.second, 3 : self.third}) def __getitem__(self, x): try: return(self.index[x]) except KeyError: print("""KeyError!\nOnly keys 1-3 are stored in this class!""")
现在让我们试着索引这种类型。首先，我们当然需要初始化这个对象的一个新实例，然后我们将索引它。这是通过[]语法完成的:
race_winners = Winners("Nancy", "Bobby", "Reagan")
首先让我们试着用 4 来表示它，看看我们得到什么样的回报！
race_winners[4]KeyError!
Only keys 1-3 are stored in this class!
现在我们将在该类的索引中打印 1:3:
print(race_winners[1])print(race_winners[2])print(race_winners[3])Nancy
Bobby
Reagan
Python 中的可索引类型
Python 编程语言提供了几种可以立即索引的数据类型和数据结构。本文中我们首先要看是字典数据结构。
dct = dict({"A" : [5, 10, 15], "B" : [5, 10, 15]})
我们可以使用相应的字典键来索引字典。这将给出给定键的值对。这将方便地为我们提供下一个数据结构，列表:
lst = dct["A"]
列表可以用我们想要访问的元素的位置来索引。例如，我们新列表的第二个元素是 10。我们可以用这个来称呼它
lst[1]
当然，这是一个，而不是两个，因为在 Python 中索引是从零开始的。不用说，使用列表索引肯定会派上用场。我们可以索引的另一种类型是字符串:
"Hello"[1]'e'
设置索引
与调用索引同等重要的是设置索引。设置索引不仅允许我们在列表和其他可迭代的数据结构上创建新的位置，还允许我们改变数据结构内部的现有值。此外，我们可以使用这种方法将关键字放入字典，将列添加到 Pandas 数据帧，等等。在 Python 中，索引设置调用 setitem()方法。让我们继续为此编写一个函数:
def __setitem__(self, x, y):
pass
现在，我们将在这个新函数中编写一点逻辑，允许它将相应的字典键的值设置为新的输入值:
def __setitem__(self, x, y):self.index[x] = y
现在，我们可以将比赛位置的指数设置为新值:
print(race_winners.index.values())dict_values(['Nancy', 'Bobby', 'Reagan'])race_winners[2] = "John"print(race_winners.index.values())dict_values(['Nancy', 'John', 'Reagan'])
当然，同样的概念也适用于 Python 中的所有数据结构。我们可以将此应用于列表、字典值，但不能应用于字符串，如下所示:
z = [5, 10]z[1] = 1d = dict({"h" : 5, "z" : 6})d["z"] = 5assert d["z"] == d["h"]assert z[1] < z[0]
重要功能
现在我们已经了解了索引的基本知识，让我们来看一下在处理数据结构时可能会用到的一些重要函数。这些函数中有许多对于处理大量数据非常有用。应该注意的是，这些函数主要用于列表和矩阵，尽管有些函数可能适用于其他结构。这将是我们要使用的这些函数的列表:
lst = [5, 1, 6, 4, 5, 7, 3,5, 4, 3, 1, 2, 3, 4,]
1.插入()
第一个有用函数是 insert。Insert 将允许你在一个数组中的任何索引处放置任何值。如果您希望特定数组在某个位置包含特定组件，这将非常有用。它非常容易使用，只需添加两个参数，位置，然后是你想要添加的值。
lst.insert(5, 3)
2.追加()
下一个函数是 append 函数。这个函数经常用于生成列表，通常是在迭代中。这将为下一个可用索引添加一个值，并且只需要一个值作为参数。
lst.append(5)
对于这种特殊情况，更好的方法可能是 lambda with mapping，或者如果是 series 类型，可能是 apply 方法，在这种情况下，我将使用迭代循环和 append 函数来演示如何以这种方式使用它:
lst2 = []for z in lst: lst2.append(z * 3 + 2)
3.移除()
Remove 将从给定列表中删除一个值。注意，这需要一个值，而不是一个索引！它也只会移除给定值的一个实例。
lst.remove(1)
4.扩展()
extend 函数本质上只是 append()方法，但是允许我们将一个列表追加到列表的末尾:
lst.extend([101, 503])
5.计数()
Count 将返回一个整数，它是给定列表中某个元素的所有实例的计数。
lst.count(5)4
这个函数的一个很好的用例是计算模式。观察我如何使用 count 和字典在迭代循环中获得模式:
digit_n = {}for x in set(lst): cnt = lst.count(x) digit_n[cnt] = x mode = digit_n[max(digit_n.keys())]print(mode)5
6.排序()
我想讨论的最后一个重要列表函数是 sort()函数。该函数不带参数，将对列表进行逻辑排序，或者按照关键字参数的指定进行排序。在下面的例子中，我使用 sort 来查找列表的中值:
lst.sort()
medianindex = int(len(lst) / 2)print(medianindex)print(lst[medianindex])
结论
不用说，在编写任何涉及数据的代码时，索引是一件非常重要的事情。list 类的标准函数对于操纵、创建和从数据中获得洞察力也非常有用。我认为这是所有人都想知道的关于 Python 中索引的内容。非常感谢你的阅读，我希望你有一个美好的白天或夜晚休息！
关于 Python 中迭代列表的所有知识
Python — 30 天挑战
在本文中，我们将研究 Python 中迭代器的各种函数和循环方式
想了解 Python 中的高级迭代方式吗？你来对地方了。许多 Python 开发人员在遍历各种迭代器时使用简单的for和while循环，但是 Python 中有许多帮助函数可以让你的代码更简单甚至更快。
图像来自像素
在本文中，我们将了解以下内容:
for回路while循环enumeratezip- 列出理解
lambdamapfilterreduce
这是我 30 天文章写作挑战的一部分。请随意查看我的新人帖子上的文章:
https://nouman10.medium.com/lets-publish-30-articles-in-30-days-a0b8111855bb
For循环
让我们从基础开始。For 循环几乎出现在每一种编程语言中，它们的用法都非常相似。但是在 Python 中，for 循环可以以多种方式使用:
按值:
我们可以遍历一个列表，每次都得到它的值，如下所示:
输出将是:
作者图片
按索引:
我们可以通过使用range()函数并传递列表的长度来遍历列表。它将返回从 0 到列表末尾的索引。
输出将与上面相同。
While循环
与 for 循环类似，while循环也很常见，在各种语言中的用法也很相似。我们通常从定义一个带有初始值的计数器和基于该计数器的条件开始，当条件为真时，允许 while 循环运行。然后我们以某种方式改变 while 中的计数器，在某个时刻条件变为假。
输出将与上面相同。
列举:
enumerate函数让我们可以同时访问索引和列表中的值，如下所示:
这将给出如下预期的输出:
作者图片
邮编:
有时，我们需要同时遍历两个或更多的列表。zip是一个很棒的函数，它允许我们访问两个列表中相同索引处的值。在不相等列表的情况下，较小列表的长度被认为是最大索引。zip函数基本上通过从每个列表中选择一个值来创建元组的迭代器，如下所示。如果我们尝试将输出转换为列表，它基本上是一个元组列表:
作者图片
列表理解:
列表理解是以更紧凑的格式使用 for 循环的另一种方式。它们允许你在一个列表的每个元素上执行一个操作，例如转换。它们还可以用于过滤目的，因为您可以在其中包含 if…else 语句。
转型:
作者图片
过滤:
只有当数组中的元素是偶数时，下面的代码才会将该元素的值加倍:
作者图片
我们还可以使用 if…else 语句，如果数量是奇数，则将其增加三倍:
作者图片
λ:
lambda功能不用于迭代，但在使用map、filter和reduce功能时很有帮助。它创建了一个匿名函数，您可以将它应用于一个值列表，即任何值。其格式可以定义为:
lambda argument(s): return value
作者图片
为了更好地理解它，这个函数也可以写成如下形式:
地图:
顾名思义，map函数将一个函数映射到列表中的每个值。它接受函数作为第一个参数，数组作为第二个参数。它返回一个 map 对象，该对象可以被迭代，但不能打印为一个完整的列表，但可以转换为一个列表
作者图片
过滤器:
filter函数将一个函数映射到列表中的每个值，如果该函数为该值返回 true，则返回该值，否则跳过它。以下函数仅在偶数时返回值:
作者图片
减少:
reduce function 基本上将一个元素列表简化为一个元素。您从一个默认值开始，然后通过reduce传递的函数应用于列表中的每一项。关于reduce函数的一个棘手的概念是reduce中使用的函数接受两个参数。第一个是到目前为止的累积值，下一个是列表中的当前元素。第一个参数是开始时的默认值。我们可以使用下面的代码来计算一个使用reduce的数组的和:
我们从默认值 0 开始，并不断添加元素。
作者图片
结论:
总结一下:
- 我们从几乎每个开发人员都使用的基本 for 和 while 循环开始。
- 然后，我们研究了一些更有效、更简单的迭代函数以及列表理解。
- 最后，我们在各种函数中使用了
lambda,用于转换、过滤和各种目的。
如果您觉得以上内容对您有用，请分享并随时支持我–>
关于 Python 中的列表，您需要知道的一切
Python — 30 天挑战
在本文中，我们将从基础开始，深入探究列表在 Python 中能做的一切
Python 中的列表或其他编程语言中的数组基本上是一种复合数据结构，它基本上可以保存一个项目列表。本文为初学者提供了一种在 Python 中使用列表的友好方式。我们将在这篇文章中讨论很多关于列表的内容，所以让我们开始吧！！
图片来自 Unsplash
以下是我们将在列表上讨论的主题列表(双关语 xD):
- 列表介绍
- 列表的常用方法
- 列表迭代
- 将列表用作堆栈
- 将列表用作队列
- 结论
这是我 30 天文章写作挑战的一部分。请随意查看我的新人帖子上的文章:
https://nouman10.medium.com/lets-publish-30-articles-in-30-days-a0b8111855bb
列表介绍
Python 有很多可以用来存储条目列表的数据结构，但是列表是最通用的一种。它被写成用方括号括起来的逗号分隔的值列表。
array = [1, 2, 3, 4, 5, 6, 7]
array
作者图片
python 中的列表可以进行索引(0 索引，允许负索引)和切片，如下所示:
array = [1, 2, 3, 4, 5, 6, 7]
print(array[0])
print(array[-1])
print(array[2:5])
作者图片
列表也允许如下连接(但不会像这样修改原始列表，除非您将值存储在该变量中):
array = [1, 2, 3, 4, 5, 6, 7]
print(array + [8, 9, 10, 11])
作者图片
列表是可变的，也就是说，可以像下面这样改变它们的内容:
array = [1, 2, 4, 4, 5, 6, 7] # 4 instead of 3 on index 2
array[2] = 3
print(array)
作者图片
我们也可以给列表的片段赋值(这可能会也可能不会改变它们的长度):
array = [1, 2, 3, 4, 5, 6, 7]
array[2:5] = [5, 4, 3]
print(array)
array[2:5] = []
print(array)
作者图片
列表可以包含不同类型的对象，甚至列表中的列表！(嵌套列表)
array_1 = [1, 2, 3, 'a', 'b', 'c']
array_2 = [4, 5, 6, 7]
combined = [array_1, array_2]
print(combined)
作者图片
关于列表的介绍就到此为止。让我们看看列表中常用的一些方法
列表的常用方法:
在这里，我们将研究 python 中应用于列表的一些常用方法，最后，我们将看到所有这些方法的演示:
注:*list* 、 *list_1* 、 *list_2* 均代表某种任意的列表。
len:
顾名思义，它返回一个列表的长度。
语法:len(*list)*
追加:
它允许我们将任何项目添加到列表的末尾。
语法:*list*.append(item)
扩展:
它将一个列表中的所有项目追加到另一个列表中。
语法:*list_1*.extend(*list_2*)
插入:
它在提到的索引中插入给定的项目
语法:*list*.insert(index, item)
移除:
它从列表中移除给定项的第一个匹配项。如果项目不存在，它会引发一个ValueError
语法:*list*.remove(item)
流行音乐:
它从给定的索引中移除该项并返回该项。在没有给定索引的情况下，它从列表中删除最后一项并返回。
语法:*list*.pop()或*list*.pop(index)
清除:
顾名思义，它清除列表(清空列表)
语法:*list*.clear()
索引:
它在列表中搜索给定的项，并返回它在列表中第一次出现的索引，如果它不在列表中，则返回-1。它还有可选参数， *start，*和 *end，*限制列表内的搜索空间
语法:*list*.index(item)
计数:
返回给定项目在列表中出现的次数
语法:*list*.count(item)
排序:
就地排序列表，即修改原始列表
语法:*list*.sort()
反转:
原地反转列表
语法:*list*.reverse()
副本:
返回列表的一个浅拷贝
语法:*list*.copy()
演示:
输出:
作者图片
列表迭代:
列表迭代是一个独立的主题，我在以前的一篇文章中详细讨论过:
将列表用作堆栈:
堆栈根据后进先出算法执行操作。通过使用内置方法，列表可以很容易地充当堆栈。要将任何元素追加到列表的末尾，我们可以使用list.append(item)并从列表中检索任何元素，我们可以使用list.pop()而不使用任何索引，这将移除并返回列表中的最后一个(追加的)元素。
作者图片
将列表用作队列:
队列根据 FIFO(先进先出)算法执行操作。为此，我们可以通过使用列表的索引方法pop和insert来使用列表，但这样效率不高，因为从列表末尾开始的追加和弹出非常快，而在列表开头的弹出和插入效率不高，因为所有元素都必须移动一个索引。
幸运的是，Python 有一个内置的collections.deque，可以实现快速追加和从两端弹出。
作者图片
结论:
总结一下:
- 我们从 Python 中列表的基本介绍开始
- 然后我们研究了列表的一些内置方法
- 最后，我们研究了如何将列表用作堆栈和队列。
如果您觉得以上内容对您有用，请分享并随时支持我–>
了解多重共线性以及如何在 Python 中检测多重共线性
它是什么，它从哪里来，为什么不好，以及如何处理它。
Amir-abbas Abdolali 在 Unsplash 上拍摄的照片
介绍
在接下来的几篇文章中，我想写一些与回归分析相关的真正强大的主题。在很长一段时间里，我不认为线性回归有什么大不了的——我只是认为它是最简单的机器学习模型，只不过是一条最佳拟合线。
然而，随着我对回归分析和它所能提供的东西了解得越来越多，我意识到有很多强大的工具和技巧是大多数人不知道的。
所以，作为开始，我想谈谈多重共线性。具体来说，我要涵盖:
- 什么是多重共线性
- 什么导致多重共线性
- 为什么它对线性回归模型不好
- 如何检测和消除多重共线性
- 如何检测 Python 中的多重共线性
说了这么多，让我们开始吧！
什么是多重共线性？
多重共线性(或共线性)当回归模型中的一个独立变量与另一个独立变量线性相关时发生。
例如，如果我们在回归模型中使用“年龄和“年轮数”来预测树的重量。
因为树的年龄和树的年轮数(通常每年一个年轮)之间有很高的相关性，所以多重共线性将出现在该模型中。
什么原因导致多重共线性？
为了理解为什么多重共线性不好，我们必须看看回归系数(或模型参数)是如何估计的。这一部分涉及到一点线性代数，但是如果你不感兴趣，可以跳过这一部分。
注:跳过这一部分也不用担心，只要把重点放在为什么多重共线性不好以及如何消除多重共线性上就可以了。😃
请注意，回归系数是指每个变量的“斜率”,在方程 y = B0 + B1x+ B2x2 中，B1 和 B2 是回归系数。请记住，线性回归模型的要点是找到代表数据的最佳回归系数。
为了找到最佳回归系数，我们希望找到使平方误差最小的值。做了一点数学计算后，你可以用下面的等式找到最佳参数(B1，B2，…，Bp):
其中 B_hat 是包含所有单个回归系数的向量，X 是由预测变量组成的设计矩阵。
注意，为了估计 B_hat，我们在方程中假设(XTX)是可逆的。
如果 X 的列彼此线性相关(即，如果存在多重共线性)，XTX 是不可逆的，这将导致几个后果，您将在下一节中看到。
多重共线性产生的问题
概括地说，为了正确估计多元回归模型的回归系数，XTX 必须是可逆的。如果 XTX 是不可逆的，这意味着 X 的列彼此线性相关，并且存在多重共线性。
最终，多重共线性的存在会导致几个问题:
- 如果其中一个 x 变量的其中一个值仅稍有改变，则拟合的回归系数(hat)将会显著改变。
- 估计系数的方差将被夸大，这意味着难以检测统计显著性。此外，有可能 F 统计量是显著的，但单个 t 统计量不是显著的。
- 最终，多重共线性会降低预测的准确性。对于给定的模型，潜在的假设是预测变量之间的关系以及它们与目标变量的关系是相同的。但是，当存在多重共线性时，这种情况不太可能出现。
如何检测和消除多重共线性
检测模型中多重共线性的一种简单方法是对每个预测变量使用称为方差膨胀因子或 VIF 的东西。
VIF 测量模型中只有该变量的给定回归系数的方差与模型中所有变量的给定回归系数的方差之比。
VIF 为 1(最小可能 VIF)意味着测试的预测值与其他预测值不相关。VIF 为 1(最小可能 VIF)意味着测试的预测值与其他预测值不相关。
VIF 越高，
- 一个预测值与其他预测值的相关性越大
- 标准误差被夸大得越多
- 置信区间越大
- 系数被评估为统计显著的可能性越小
可接受的 VIF 小于 10 和 1/1-R 模型的最大值(见下文):
如何用 Python 实现 VIF
举个例子，我要用 Kaggle 的加州房价数据集。
首先，我导入了所有相关的库和数据:
import pandas as pd
import numpy as np
from statsmodels.stats.outliers_influence import variance_inflation_factor
接下来，为了简单起见，我只选择了 3 列作为我的特征(X 变量),并删除了所有的空值和无穷大值:
df = pd.read_csv('housing.csv')
df = df[~df.isin([np.nan, np.inf, -np.inf]).any(1)]
X_variables = df[['total_rooms','total_bedrooms','median_income']]
最后，我计算了 X 变量的 VIF:
vif_data = pd.DataFrame()
vif_data["feature"] = X_variables.columns
vif_data["VIF"] = [variance_inflation_factor(X_variables.values, i) for i in range(len(X_variables.columns))]
就这样，我们得到了最后的结果:
直觉上，这完全说得通。房间总数和卧室总数远远高于 VIF 阈值，表明这些变量之间存在高度共线性。我们可以直观地理解这一点，因为房间数和卧室数之间有很强的相关性(卧室越多，房间越多，反之亦然)。
感谢阅读！
我希望您发现这很有用，并且您学到了一些新东西！多重共线性是回归分析中一个极其重要的概念，因此它绝对是一个需要理解的重要概念。
不确定接下来要读什么？我为你挑选了另一篇文章:
</40-statistics-interview-problems-and-answers-for-data-scientists-6971a02b7eee>
又一个！
[## 六分钟内解释所有概率分布
towardsdatascience.com](/all-probability-distributions-explained-in-six-minutes-fe57b1d49600)
特伦斯·申
关于 Push 你需要知道的一切！在朱莉娅
用力！()方法是你需要了解的 Julia 基础的重要部分。让我们来看看它能做什么。
(图片由蒂姆·莫斯霍尔德在【Unsplash.com】T2 拍摄)
Julia 编程语言有一个丰富和扩展的基础，它本身能够做很多事情。Julia 与许多其他编程语言的不同之处在于它健壮的类型系统。方法系统当然伴随着这个很好，然而类型系统才是真正的抢镜。还有一些很棒的方法可以处理 Julia 中的所有类型。如果您使用 Julia 已经有一段时间了，那么您很可能已经遇到了推送！()野外法。该方法很常用，因为它是 Julia 的核心特性。也就是说，那些对 Julia 感兴趣的人可能想获得一些使用它的经验。
Julia 语言的一个优点是一个方法定义本质上有无限的能力。这是一个非常朱利安的事情进口推动！()方法，并扩展它以处理您环境中的类型。方法中也有一些不规则和奇怪的东西，可能很重要，其中一些甚至是一些有经验的 Julian 程序员也没有经历过。今天，我们将从核心 Julia 数据类型的基础开始，介绍该方法的所有细微差别，然后我想介绍如何扩展该模块以使用类型的示例实例。这个项目还有一个笔记本，您可以在这里查看:
https://github.com/emmettgb/Emmetts-DS-NoteBooks/blob/master/Julia/Push in julia.ipynb
用力！:基础知识
我们将从一个简单的数组开始:
example = [9, 7, 4, 28]
关于数组，有一些特殊的事情需要注意:
- 它们是可重复的。
- 它们是 base Julia，所以 base-Julia 方法与它们一起工作。
与许多其他语言不同，我们有一个相当健壮的索引接口。既然这些都是可重复的，只要一推！()方法知道如何处理我们传递的 iterable，它可以将我们想要的任何类型放入其中——这很方便，因为像 append！()方法只方便某些数据类型的使用。我们可以用？(推！)来了解关于这个函数的更多信息，这也将给出这个函数的所有不同调用:
?(push!)
这在朱莉娅是一个很好的实践。那个？()方法允许我们尽可能深入地快速浏览文档。与传统上可能在 web 浏览器中查找一些文档相比，这种文档字符串系统有很多非常好的优点。实际上，我写了一整篇文章，更详细地讨论了 Juliahub 系统的文档，如果你不知道这两件事，你可能会感兴趣，下面是这个故事的链接:
从中我们可以看出一点，它将会变异成我们提供的第一个论点。在深入研究之前，我们可以立即指出这一点，因为这个方法在一个解释点结束。这是另一个深入到背后故事的很酷的故事:
回到我们的笔记本，我们已经对这个方法有了很好的了解，但是让我们看看实际的文档能告诉我们什么。
(图片由作者提供)
该文档为我们提供了一个 REPL 绑定的示例、详细描述的参数，甚至一些在不同情况下使用的其他方法。前面提到的追加！()在这里做了一个重要的注释，作为 append！如果追加是我们真正想要做的，那么()可能是某些结构的更好应用。我们将遵循这些参数，并为我们的旧示例数组加入一些新数据。
push!(example, 5)5-element Vector{Int64}:
9
7
4
28
5
这将产生一个 5 元素的数组，一个整数向量，它将改变数组的维数和数组中的可迭代内容。奇怪的一点是，有一些细致入微的类型是不能推的。我们通常可以很好地将结构推进这里。然而，对于某些数据类型，甚至是构造类型，它将不起作用。
多带推！()
正如我前面提到的推！()，当涉及到类型时，这个方法有一些细微的差别。我发现提供范围生成器的例子很奇怪:
**push!(example, 1:5)**MethodError: Cannot `convert` an object of type UnitRange{Int64} to an object of type Int64
Closest candidates are:
convert(::Type{T}, ::T) where T<:Number at number.jl:6
convert(::Type{T}, ::Number) where T<:Number at number.jl:7
convert(::Type{T}, ::Base.TwicePrecision) where T<:Number at twiceprecision.jl:250
这是一个很难辨别的错误，我觉得可能会让初学者感到困惑。这里的 stack-trace 并没有很好地展示出做错了什么，除非人们意识到这里的问题是键入。我们得到这个错误的原因是因为我们提供的类型是一个 UnitRange，但是每当它被添加到 vector 时，我们都会得到一个转换尝试。这是因为向量只能包含整数，因为它的类型是
Vector{Int64}
我们当然可以改变这一点。在 Julia 中，这可以通过将这个向量转换成一个可以包含任何类型的值的数组来实现。但是，这将改变行为，这可能是范围生成器所不希望的，例如:
push!(Array{Any}(example), 1:5)6-element Vector{Any}:
9
7
4
28
5
1:5
现在我们有一个 6 元素数组，里面有不同的类型，单位范围和那些整数在一起——我们可能期望在数组的末尾添加 1、2、3、4 和 5。这可能看起来更像是预期的行为，但通常这就是推动的方式！()方法会起作用。
延伸推！()
在一个真正的朱利安时尚，我们现在要延长推！()更好地配合我们的 UnitRange。每当我们想通过调度来扩展某种功能时，第一步就是直接导入它:
import Base: push!
如果你不知道如何扩展方法，就像这样，我就不在这里赘述了，但我有两篇文章，其中一篇有视频，在 Julia 中详细介绍了这一点:
https://medium.com/chifi-media/extending-julias-base-for-our-superframes-jl-package-4574555ff6ae
希望现在这个概念在你的头脑中是新鲜和熟悉的，这将更容易理解我到底想做什么。我们的目标输入参数将是:
- 我们的收藏
- 单位范围
我们想要的输出是集合中的所有元素。首先考虑我们的输入及其类型，让我们定义这个新函数:
function push!(collection::Vector{Int64}, range::UnitRange)
[push!(collection, i) for i in range]
end
更快的方法可能是使用 collect()方法。
在函数内部，我有一个简单的迭代循环，它解包范围内的单个值，以便提供这个功能。每当将此新定义加载到环境中时，都可以将其添加到此方法定义的文档中:
"""## push!(collection::Vector{Int64}, range::UnitRange)
This method can be used to unpack a range generator and return its elements pushed into the collection. \
julia> push!([2, 3] 1:2)4-element Vector{Int64}
2
3
1
2
function push!(collection::Vector{Int64}, range::UnitRange)
[push!(collection, i) for i in range]
end
现在让我们看看我们的？()前一个示例的文档调用:
?(push!)
(图片由作者提供)
幸运的是，我们的新定义被附加到其他文档中。我相信在这两组文档之间使用某种区分是有用的，因为 push！(::Vector{Int64}，::UnitRange)调用增加了一些不同的功能。这也是我们直接引用该调用的方式，例如:
?(push!(::Vector{Int64}, ::UnitRange))
(图片由作者提供)
让我们最后使用这个函数，看看将要进行的最后一次调用:
push!(example, 1:5)10-element Vector{Int64}:
9
7
4
28
5
1
2
3
4
5
这可能看起来工作量很大，为此要编写一个完整的方法扩展。然而，在您的编程语言中，在整个软件包生态系统中使用相同的方法调用简直令人惊奇。我们避免了命名冲突，并且能够根据类型反复使用相同的别名。虽然您可能希望编写一次 for 循环，但您可能不希望在这段代码的每个实例中反复编写它。也就是说，这就是函数的用途，把你的新函数写成一个众所周知的定义可能会让你的用户猜测如何更有效地使用你的包！
结论
右推！()挺牛逼的。这个方法的伟大之处在于它有许多不同类型的功能。我相信这是通过抽象来实现的，因为一般来说，Julia 中的大多数类型都是一个更大的类型层次结构的一部分，这个层次结构可以限制方法的行为。Julia 有很多优点，但有一点对我来说非常突出，那就是它的可扩展性。很少有人模仿 Julia 对多个分派和文档的处理，而且最重要的是，Julia 中的整个名称定义都可以重用和扩展。厉害！谢谢你的阅读，我希望你有一个可爱的一天！
关于 Python 中的 Zip，您需要知道的一切
Python 的 zip 类型的所有重要内容的概要。
(src =https://pixabay.com/images/id-2923487/
介绍
迭代是程序员在处理可迭代数据结构时非常常用的技术。迭代可能相当复杂，有时相当困难。有些情况下，迭代 for 循环可能无法非常有效地完成工作。也就是说，对于一次迭代多个元素的情况，列表的典型迭代可能会有问题。幸运的是，Python 为这个问题提供了一个很好的解决方案，叫做 zip。
Zip 很棒，因为它允许我们同时处理两个或更多的数据结构。使用 zip，我们可以在 Python 中同时迭代遍历多个对象。不用说，这在很多情况下都会派上用场。我还擅自将这款笔记本添加到了 Github 库，您可以在这里查看:
Zip 是什么？
Python 中的 zip 对象就是所谓的迭代器。迭代器在循环中使用，通常是基于元素的循环。给定名称，我们可以假定这些通常与迭代一起使用。Zip 是由 Python 的基础提供的，所以我们可以在语言的任何地方调用它。为了创建一个 zip 对象，我们简单地将两个 iterables 传递到它的初始化函数中:
x = [5, 10, 15]
y = [5, 10, 15, 20]
zipper = zip(x, y)
现在让我们来看看这个新迭代器的类型:
type(zipper)
现在我们可以在 for 循环中调用这个新的迭代器，以便同时遍历这两个列表中的元素。我不记得 Python 是否接受这个或一个元组的参数，因为没有答案的都是我们在 Julia 中做的。但是，我很确定这是 Python 中的参数，所以让我们试试:
[print(i, c) for i, c in zipper]
通常，该对象不会在迭代循环调用之外构造，因此使用 zip 类型的典型迭代循环通常是这样构造的:
for i, c in zip(x, y):
print(i, "\n")
print(c)
作者图片
重要细节
既然我们已经有了 zip down 的基础，现在让我们回顾一下关于这个类的所有重要细节。首先，我们需要理解为什么需要调用这个迭代器来进行实际迭代。通常在这种情况下，我们的迭代器会自动开始循环，而不需要创建 for 循环。
这是因为 zip 对象就是我们所说的惰性迭代器。懒惰迭代器之所以懒惰，是因为它们自己不做太多事情。尽管如此，当与 for-loop 语法结合使用时，它们会非常强大。接下来我要讲的是数组中元素的数量。
你可能已经注意到，在上面的例子中，x 和 y 是不同的维度。这是有意的，因为接下来我想演示的是当我们滑过数组时会发生什么，这就是情况。当然，在典型的应用程序中，情况并非如此，因为在 zip 迭代器中遇到这种情况的可能性似乎要小得多，然而，关于对不同维度的数组使用 zip，您可能需要知道一些事情。
您应该知道的第一件事是，zip 迭代器只会迭代较短的 in 元素。这意味着更大的数组中的任何元素都将被截掉，如下面的演示所示，我们看到当 y 的长度为 4 时，我们只得到三个不同的打印输出。
for i, c in zip(x, y):
print("I:")
print(i)
print("\n")
print("C:")
print(c)
print("\n")
print(len(x))
print(len(y))
如果我们想改变这一点，我们可以使用 itertools 模块中的 zip_longest。这个模块在标准库中，提供了一系列不同的迭代工具和迭代器，可以用来加速 Python，或者执行不编写自己的迭代器就不可能执行的迭代。如果你想了解更多关于 Itertools 的功能，我有一篇文章可以提供给你:
zip_longest 迭代器将参数迭代到最长元素的末尾。如果您不想遗漏任何值，这可能会很有用。任何没有被循环的元素都将被返回为 None，如下例所示:
from itertools import zip_longest
for i, c in zip_longest(x, y):
print("I:")
print(i)
print("\n")
print("C:")
print(c)
print("\n")
print(len(x))
print(len(y))
结论
当我们使用多个数组并希望以某种形式使用迭代时，Zip 是一个很好的工具。迭代器有一些细微差别，但一般来说，这是一个非常好的概念，许多高级程序员都习惯和熟悉它。也就是说，从各个方面了解它可能会在找出一些奇怪的输出或错误时派上用场。感谢您的阅读！
关于深度学习模型的“激活函数”，你需要知道的一切
想知道什么是激活功能，为什么它们必不可少？
艾莉娜·格鲁布尼亚克在 Unsplash 上的照片
我们知道深度学习模型是激活函数、批量归一化、动量、梯度下降等不同成分的组合。因此，在这篇博客中，我选择了 DL 的一部分，通过回答以下问题给出了关于激活功能的详细解释:
- 什么是激活函数？
- 为什么我们在神经网络中需要一个激活函数，如果我们不使用，会发生什么？
- 激活函数的期望属性是什么？
- 有哪些不同类型的激活功能及其用途？
对于这个博客，我假设你们都对神经网络有一个基本的了解。所以事不宜迟，让我们更深入地研究激活函数。
激活功能
激活函数是一个函数，用于变换神经网络中前一节点的输出信号。这种转换有助于网络学习数据中的复杂模式。就是这样！一开始我也不相信事情会这么简单，但这是真的。
激活函数转换前一个节点的输出(图片由作者提供)
需要激活功能
是的，你现在已经知道基本原因了。有必要使神经网络能够学习数据中的复杂模式。但是它是如何实现的呢？激活函数通常是非线性函数，它给神经网络增加了非线性，从而允许它们学习更复杂的模式。还不清楚？让我们看一个神经网络的例子来理解这一点。
神经网络(图片作者提供)
对于这个例子，请假设我们没有添加偏差。我们可以将输出 Y 写成:
作者图片
其中 Act 表示我们的激活函数的输出，(这是一个非线性变换)。现在假设我们没有网络的任何激活函数，那么我们的 Y 看起来像这样:
作者图片
如果你仔细看上面的等式，那么
作者图片
这意味着，即使我们的网络中有两层，输入和输出关系实际上也可以由单个权重矩阵来定义(这是两个权重矩阵的乘积)。因此我们看到，在没有激活函数的情况下；我们给神经网络增加多少层并不重要，它们都可以被简化，只用一个权重矩阵来表示。但是，当我们添加激活函数时，它们会添加非线性转换，这使得我们无法简化多层神经网络。
激活函数的另一个重要性是，它有助于将神经元的输出值限制在我们需要的范围内。这一点很重要，因为激活函数的输入是 W*x + b ，其中 W 是单元的重量，而 x 是输入，然后还有偏置 b 加入其中。如果不受限制，该值可以达到非常高的量级，尤其是在处理数百万个参数的非常深的神经网络的情况下。这进而导致计算问题以及值溢出问题。
我知道没有激活函数的例子，很难理解我扔给你的所有事实，但是请耐心听我说。我们将很快在一个例子中回顾所有这些概念，但是为了你更好的理解，它们需要在这里被覆盖。
激活函数的期望属性
- 从上面可以清楚地看出，激活函数应该是非线性的**。**
- 在神经网络的每一层之后使用激活函数，因此，总是希望激活函数在计算上高效。
- 对神经网络的所有组件的主要要求是它们应该是可微分的，因此激活函数应该也是可微分的。
- 设计激活函数的一个重要方面是防止消失梯度问题。深入解释这个问题超出了本博客的范围，但让我给你要点。为了防止消失梯度问题，要求激活函数 w.r.t 输入参数的导数在理论上是不有界在 -1 到 1 之间。
不同类型的激活功能
热卢
ReLU 代表RectivedLlinearUnit，定义为 f(x) = max(0，f(x))
ReLU 图(图片由作者提供)
这是一个广泛使用的激活函数，尤其是与 CNN(卷积神经网络)一起使用。它易于计算，不会饱和，也不会导致梯度消失的问题。但是，它有一个问题，即对于负输入，它的值变为零。由于所有负输入的输出都是零，这导致一些节点完全死亡，什么也学不到。为了处理这个问题，使用了漏 ReLU 或者参数 ReLU，即 F(x) = max(αx，x)。
泄漏的 ReLU(图片由作者提供)
乙状结肠的
这个激活函数在计算上是昂贵的，导致消失梯度问题，并且不是零中心的。这种方法通常用于二进制分类问题，并且仅在神经网络的末端使用，以将输出转换为范围[0，1]。这个函数一般不在神经网络内部使用。
Softmax
用于多类分类问题。像 sigmoid 一样，它产生 0-1 范围内的值，因此，它被用作分类模型中的最后一层。
结论
我希望在这个解释之后，你现在能更好地理解为什么神经网络需要激活函数，以及激活函数的性质和类型。如果你觉得有帮助，请在这个博客上发表评论，让我们知道。
关注我们的 medium 了解更多此类内容。
成为 介质会员 解锁并阅读介质上的许多其他故事。
自动化 OSX 所需的一切
当我们想到自动化工作负载、可重复流程、“一键式”部署或类似的东西时，我们通常会想到笔记本电脑。我们在做任何事情的时候都在练习 DevOps，为什么我们的笔记本电脑会被忽视呢？毕竟，我们都同意“宠物”是坏的，“羊”是好的。如果您的笔记本电脑现在没电了，您需要多长时间才能将一台新电脑完全设置到正常工作状态？
对我来说，答案大概是 10-15 分钟的工作和 30 分钟的等待(咖啡休息时间！万岁。).
除非你运气特别差，否则你不需要经常更换你的工作笔记本电脑。但是如果你的笔记本电脑升级到新的型号呢？如果你的笔记本电脑坏了怎么办？如果你买了一台新的个人笔记本电脑会怎么样？如果你不得不做一件事不止一次，为什么不自动化呢？
这是我大约两年前经历的思考过程，从那以后，设置一台新的笔记本电脑就不再是一个问题。让我向您介绍我的过程，并向您展示如何自动化您的 OSX 设置。
先决条件
要使这一过程成功，需要做好几件事情:
- 您需要在笔记本电脑上登录您的 iCloud 帐户
- 你需要一个云存储服务(例如 Dropbox、iCloud、Google Drive)
- 您的引导脚本(我们将一起创建)和配置文件应该存储在这个云存储服务中。
就是这样！这就是使用此流程所需的全部内容。
过程
在我开始向您展示代码片段之前，我想先介绍一下我们正在努力实现的目标，以及我们将如何实现它。
我们将编写并运行一个 bash 脚本，它将:
- 检查
xcode、&、brew是否安装，如果没有安装。 - 使用
brew，我们还将安装一个名为mas的应用。此应用程序允许您通过 CLI 从 App Store 安装应用程序。 - 使用
brew和mas安装我们想要的任何东西。 - 使用云存储服务上的配置文件配置笔记本电脑。
当我们完成时，我们所有的键绑定、别名、AWS 配置文件等…都将自动设置在我们的笔记本电脑上。新的笔记本电脑应该处于与之前的硬件相同的状态。
让我们开始编码吧！
现在你知道我们在做什么，编码将会很容易。我们从以下内容开始:
**#!/usr/bin/env bash** if [ -f ~/.osx-bootstrapped.txt ]; then
cat << **EOF** ~/.osx-bootstrapped.txt FOUND!
This laptop has already been bootstrapped
Exiting. No changes were made.
**EOF** exit 0
fi
CURRDIR=`pwd`
BREWINSTALLED=`which brew`
XCODEINSTALLED=`which xcode-select`
# Install Xcode
if [[ ${XCODEINSTALLED} == "" ]]; then
echo "Installing Xcode"
xcode-select --install
fi
# Install Brew
if [[ ${BREWINSTALLED} == "" ]]; then
echo "Installing Brew"
ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
fi
我们做的第一件事是检查这个脚本以前是否被执行过，如果是，我们不希望它再次运行，并将优雅地退出。检查完成后，我们开始工作。
接下来，我们检查是否使用which命令安装了xcode和brew。如果在本地系统上找不到它们，我们将安装它们。
下一部分将因人而异，因为并非所有人都使用相同的应用程序。
#Required App
brew tap homebrew/cask
brew install mas#List your preferred applicationsbrew install --cask intellij-idea
brew install --cask google-chrome
brew install --cask slack
brew install --cask spotify
brew install --cask spectacle
brew install --cask karabiner-elementsbrew install jq
brew install awscli
brew install terraform
brew install packer
brew install docker-compose
brew install mysql-clientmas install 1295203466 #Remote Desktop
以上大部分都很容易理解。我们设置 brew tap/repo，并安装mas。除此之外，我正在安装我在笔记本电脑上使用的所有应用程序。我的清单要长得多，但是为了这个例子，上面的应该足够了。
节日
我想扩展的一件事是mas,因为这可能不是主流的工具。如前所述，mas 允许您使用 CLI 与 Apple App store 进行交互。这是我们将自动安装任何应用商店应用的机制。
一旦你在当前的笔记本电脑上安装了这个工具，你应该运行mas list。它将输出一个列表，列出所有安装在你的笔记本电脑上的应用程序及其 id。
➜ mas list | egrep 'Numbers|Key|Remote'
1295203466 Microsoft Remote Desktop (10.5.1)
409183694 Keynote (10.3.9)
409203825 Numbers (10.3.9)
有了这些 id，您现在可以通过运行mas install {IDNUMBER}来安装它们。关于 mas 的更多信息，请查看他们的 Github repo 。
编码继续
既然我们已经讨论了 mas，并且安装了我们的应用程序，那么我们继续配置。和以前一样，这一步对每个人来说都是不同的，但是这应该会让你知道我们在努力做什么以及如何做。
# Symlink my configs
ln -s $CURRDIR/aws/ ~/.aws
ln -s $CURDDIR/bash_profile-config ~/.bash_profile
#Remove default karabiner dir since we are providing our own
rm -rf ~/.config/karabiner
ln -s $CURRDIR/karabiner-config ~/.config/karabiner# ln -s $CURRDIR/karabiner-config/karabiner.json ~/.config/karabiner/karabiner.json
# Remove Spectable default shorcuts json since we are providing our own
rm -f ~/Library/Application\ Support/Spectacle/Shortcuts.json
ln -s $CURRDIR/spectacle/Shortcuts.json ~/Library/Application\ Support/Spectacle/Shortcuts.json
因为所有的配置文件都在云中，所以这一步就像创建一个符号链接一样简单。您可以复制文件，而不是创建符号链接。然而，我更喜欢符号链接，因为这意味着我所有的笔记本电脑都使用相同的配置。如果我在我的一台笔记本电脑上添加别名，它将在我所有的笔记本电脑上可用。
我们的最后一步是安装‘哦，我的 Zsh’并创建我们的osx-bootstrapped.txt文件。
if [ ! -d ~/.oh-my-zsh ]; then
sh -c "$(curl -fsSL https://raw.githubusercontent.com/robbyrussell/oh-my-zsh/master/tools/install.sh)"
rm ~/.zshrc
ln -s $CURRDIR/zshrc-config ~/.zshrc
fi
touch ~/.osx-bootstrapped.txt
你可以传递“哦，我的 Zsh ”,但是如果你还没有使用它，我强烈建议你去看看。
结论
我们都同意“宠物”是坏的，“羊”是好的。我们的笔记本电脑不应该有任何不同。鉴于笔记本电脑的重要性，这一点尤为重要。如果您按照上面的代码片段创建了自己的脚本，您就再也不用担心您的笔记本电脑会跑到天上的农场了。您还可以获得在所有笔记本电脑上获得一致体验的额外好处。只要 10 到 20 分钟的工作，你就能得到所有这些。非常值得投资回报！
为了获得无限的故事，你还可以考虑注册https://blog.rhel.solutions/membership成为中等会员，只需 5 美元。如果您使用 我的链接 注册，我会收到一小笔佣金(无需您额外付费)。
家得宝数字化转型的证据
一次周末的零售之旅激发了人们对数字化转型典范的关注。
布鲁克·拉克在 Unsplash 拍摄的照片
这个周末，当我在家得宝(Home Depot)闲逛，为我的公寓寻找新的外门时，我想到了一个组织，它是从我小时候在佛罗里达州莱克兰(Lakeland)认识的大盒子零售商演变而来的。我的高中朋友会在夏天在那里工作，我一直认为这是一个令人无法抗拒的地方。
我注意到……越来越多的时候，我能够不去家得宝零售点的大型仓库，而是雇佣专业人员使用应用程序和他们的网站来安装我的家居项目。我的整个外门项目都是通过他们的网站、呼叫中心和店内测量预订的。他们是如何变得如此擅长跨越不同接触点创造无缝体验的？
答案是:数字化转型。
数字化转型正在“融合物理、生物、化学和信息世界。”托尼·萨尔达尼亚认为这是第四次工业革命，他是《为什么数字化转型会失败》一书的作者，这是一本关于数字化转型最佳实践的非常成功的书。
Saldanha 提到“零售天启”或许多主要依赖实体销售的零售商申请破产的事实是第四次革命正在影响当今企业的一个征兆。(萨尔达尼亚，2019 年)
在这篇博客中，我将介绍美国主要家装零售商家得宝的一个例子，并描述他们正在进行的数字化转型及其成功的迹象。
是什么让数字化转型成功？
成功的数字化转型意味着让您的企业能够创造永恒的运动。这意味着您正在不断发展，以便在客户需要您的产品/服务时，随时随地满足他们的需求，并以最有效的方式提供他们所寻求的价值。这意味着您已经接受了技术，使组织的所有部分都能够利用这项技术，并创建了允许您根据客户和潜在客户的速度调整业务模式的流程。
在他的第二章中，Saldanha 将一个成功的转型描述为一个连续体中五个发展阶段的顶点。他的第五个阶段，“活的 DNA”，被描述为一个不断运动的组织。他们的员工精通数字技术，他们的系统相互连接，他们采用了最具创新性的商业模式，并将继续这样做，因为他们正在以精益敏捷的方式进行测试、学习和适应。(Saldanha，2019)这个想法描述了成功的数字化转型。
家得宝的商业问题
家得宝(Home Depot)是一家总部位于美国的零售商，其成立的目的是为“自己动手”的人提供服务，其大型仓储式商店以卓越的选择、乐于助人的员工和一站式商店的优质产品使当地五金店相形见绌。(家得宝，2021 年)
该模式非常成功，但随着时间的推移，新类型的客户出现，减缓了他们的增长能力。2016 年，家得宝(Home Depot)电子商务总裁凯文·霍夫曼(Kevin Hoffman)描述了新兴的“为我动手型”消费者，他们寻求全方位服务的安装、优质产品和较少动手的家装体验。为了给顾客提供他们想要的体验，家得宝需要解决遗留技术问题，并在购物体验之初就接受电子商务和数字财产。(劳克伦，2015 年)
解决方案:一个家得宝
2018 年，家得宝公布了他们的零售体验转型计划，以专注于其电子商务平台和店内的数字化、单一、互联的体验。该系统的引入是为了给消费者提供一种“无摩擦、互联的购物体验”(家得宝，2019 年)
尝试连接不同平台和商业模式的无摩擦购物体验的想法符合萨尔达尼亚概述的数字化转型的要求。就家得宝而言，它正在将店内购物体验和员工的帮助转化为电子商务和数字体验。转型需要以数字形式反映品牌，并确保供应商/商店能够交付在这些新渠道购买的服务。
解决的关键系统，使用的技术
为了开始转型，家得宝的首席执行官推出了 One Home Depot，这是一项创造互联体验的重大举措。高层领导的这种支持，以及在季度电话会议中讨论的目标和进展，为组织的其余部分定下了基调。变革需要发生，领导力需要投入。(邦德等人，2019 年)
为了实现转型，该组织对其 IT、开发人员、数据和分析能力进行了投资。2018 年，他们在美国各地的技术中心雇用了大约 1，000 名技术专业人员。这转变了公司的能力，使他们能够开发专为新的“为我做”细分市场构建的新的移动和电子商务客户体验。(家得宝，2018 年)
家得宝还更新了其在持续集成方面的能力和来自敏捷软件开发的想法。“OrangeMethod”是该公司教育员工新的思维方式，超越他们的核心能力，使数字化转型在他们的组织中发生。它还设定了让新技术员工能够建造一个家得宝的流程。(家得宝职业生涯，2018 年)
对家得宝的影响
由于积极主动的数字化转型，该公司为应对新冠肺炎的影响做好了充分准备。尽管商店关门，这家零售商在利用消费者趋势方面取得了巨大的成功，使家装零售商受益。根据他们的 2020 年年度报告，数字销售额比上一年增长了 86%，他们的数字资产全年的流量创下纪录，整体销售额增长了 20%。(家得宝，2020 年)
正如这位首席执行官所言，“创造无缝、互联体验，融合实体和数字世界的零售商将在市场中占据有利位置。”他将他的组织 2020 的成功归功于对数字化转型的投资，正如他们在 One Home Depot 愿景中实现的那样。(家得宝，2020 年)
参考资料:
t .萨尔达尼亚(2019)。在为什么数字化转型会失败:如何起飞并保持领先的惊人法则(第 3-31 页)。散文，Berrett-Koehler 出版社，BK 商业书籍。
关于我们。家得宝。(2021).https://corporate.homedepot.com/about.
劳克伦，S. (2019，4 月 29 日)。家得宝——打造“自己动手型”顾客体验。数码杂志。https://diginomica . com/the-home-depot-building-the-do-it-for-me-customer-experience。
家得宝将提供“一个家得宝”投资战略的更新，以扩大市场领导地位。(2019 年 12 月 11 日)。家得宝。https://IR . home depot . com/~/media/Files/H/home depot-IR/2019% 20 IAC/Press % 20 release _ VF . pdf
Bonde，a .，Chirokas，m .，Shwerdlow，f .，& Beeson，M. (2019 年 7 月 19 日)。家得宝如何成为数字发电站？埃文斯顿。https://www.forrester.com/go?objectid=RES155235.
家得宝雇佣 1000 名技术专业人员。家得宝。(2018 年 4 月 18 日)。https://IR . home depot . com/news-releases/2018/04-18-2018-130228118。
家得宝职业生涯。(2018).家得宝的 OrangeMethod。Vimeo.com。https://vimeo.com/272596009.
家得宝。(2020).年报。佐治亚州亚特兰大:家得宝投资者关系。
进化计算(完整课程)概述
https://unsplash.com/photos/FHnnjk1Yj7Y
进化计算课程
关于我将在这个全新的系列中涉及的材料、概念和应用的介绍性帖子！
大家好！我决定开设一门关于进化计算的课程。在这篇文章中，我将只给出课程的简要概述！
进化计算是计算智能的一个子领域，是机器学习和人工智能的一个分支。进化计算的应用很多，从解决优化问题、设计机器人、创建决策树、调整数据挖掘算法、训练神经网络和调整超参数。
如果你熟悉数据科学和机器学习模型，所有的统计和“黑箱”模型都是为了解决优化问题而建立的。你可能熟悉这些问题，如 MSE、交叉熵、MAE 等，在这些情况下，我们希望最小化这些值。进化计算是优化理论的一个领域，它不是使用经典的数值方法来解决优化问题，而是使用生物进化的灵感来“进化”出好的解决方案。当没有适应度函数的已知导数(强化型学习)时，或者当适应度函数具有许多可能陷入序列方法的局部极值时，通常使用进化计算来代替标准数值方法。
目录
- 要覆盖的材料
- 文献应用实例
- 预赛
- 结论
要覆盖的材料
- 单元 1)最优化理论
- 单元 2)进化计算简介
- 单元 3)遗传算法
- 第 4 单元)遗传规划
- 第 5 单元)进化规划
- 第 6 单元)进化策略
- 第 7 单元)差异进化
- 单元 8)共同进化
本课程将是一个简短而深入的系列教程，涵盖上述主题。会有很多帖子，会持续很久。如果你时间紧迫，只需阅读单元 1 至 3，因为它会给你一个优化理论，整体进化计算和遗传算法的基本概述。其余的单元，即单元 4-8，实际上都是遗传算法本身的不同变体。唯一不同的是，它们针对不同的问题进行了超参数化，具有独特的特征；然而，它们都有相似的形式，都属于遗传算法的范畴。
文献论文示例
在每个单元的结尾，我们将回顾一个在同行评议文献中发现的真实世界的例子。以下是我们将涉及的各种示例:
- 单元 3)训练用于时间序列分析的前馈神经网络
- 单元 4)发展相同时间序列问题的基本方程/结构
- 单元 5)求解约束非线性规划问题
- 单元 6)求解多目标 Pareto 前沿的算法
- 单元 7)自动机器学习:设计 CNN 的架构
- 单元 8)设计玩月球着陆器的游戏 AI
预赛
下面是一些预备知识，我希望你应该知道，以便最好地应用材料和理解概念:
- 基本统计—概率分布
- 线性代数(基本概念:矩阵乘法，欧几里德距离等…)
- 数值方法(基本概念:为什么使用它们，为什么需要它们)
- 如何用 Python 编程—使用数据结构和算法
- 了解 Python 科学库——Numpy 和 Scikitlearn
结论
进化计算是解决优化问题的方法论。优化问题在机器学习和人工智能领域中大量存在。EC 通常用于经典数值方法无法找到足够好的解的情况。
好了，这应该完成了课程的基本概述！如果您对迄今为止讨论的任何主题或应用示例感兴趣，那么请不要离开，因为我们将涵盖所有这些以及更多内容！在下一篇文章中，我们将从单元 1)最优化理论开始
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
