TowardsDataScience-博客中文翻译-2021-七-
TowardsDataScience 博客中文翻译 2021（七）
设计基本神经网络的 7 个步骤(第 1 部分，共 2 部分)
一个数学不太密集的，一步一步的指南，从头开始建立一个隐层神经网络
图片由 Lindsay Henwood 在 Unsplash 上提供
这篇由两部分组成的文章采用了一种更全面、更全面(是的，更少数学化)的方法来从头构建一个神经网络。用于完成网络的 Python 也包含在 7 个步骤的每一个中。
第一部分: (1)定义网络结构，(2)初始化参数，(3)实现正向传播。 第二部分 : (4)估计成本，(5)实现反向传播，(6)更新参数，(7)进行预测。
快速背景:为什么逻辑回归对于噪音数据集是不够的
数据通常呈非线性分布，或者包含传统分类模型无法很好区分的异常边界。例如，假设我们想要对以下数据集中的红点和蓝点进行正确分类:
作者图片
我们可以从逻辑回归开始——二元分类问题的常用模型。像往常一样，我们将导入必要的库，并使逻辑模型适合 X 变量(即上面点的 X 轴和 Y 轴坐标)和 Y 结果变量(即红色或蓝色点)。
import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, confusion_matrixlogmodel = LogisticRegression()
logmodel.fit(X.T, Y.T)
predictions = logmodel.predict(X.T)
应用逻辑回归模型的边界预测，我们可以立即看到一些错误分类的发生。
plot_decision_boundary(lambda x: logmodel.predict(x), X, Y)
plt.title("Logistic Regression")
作者图片
虽然大多数点被准确预测，但一些红点被归类为蓝色，反之亦然。这个模型有点太笼统，欠拟合数据，会导致偏高。运行快速分类报告和混淆矩阵显示，我们的逻辑模型的准确率约为 87%。
print(classification_report(predictions, Y.T))
分类报告(图片由作者提供)
conf_matrix = np.array(confusion_matrix(Y.T, predictions))
pd.DataFrame(conf_matrix, index=['Purple','Red'],columns=['Predicted Purple','Predicted Red'])
困惑矩阵(图片由作者提供)
虽然这可能足以满足一些数据任务——基本的预测模型或快速的直觉检查——但神经网络在识别复杂模式(如上所述)和优化预测方面可以做得更好。
好吧，让我们开始吧！
步骤 1:定义网络结构
人们将神经网络比作大脑中的神经元，因为它们看起来相似，并且都参与学习。事实是，与大脑神经元不同，神经网络双向“发送信息”，这种独特的双向对反向传播中发生的学习至关重要(在第 2 部分中有所介绍)。
考虑到这一点，我们首先要构建我们的神经网络。如下所示，网络包含节点和层(节点列)。
基本的一层神经网络(图片由作者提供，他的女朋友不同意他的笔迹)
输入层:从左到右，我们从输入层和 2 个节点开始，每个节点代表我们数据集中的一个变量(我们的 X 变量包含 X 轴和 Y 轴坐标数据，所以它变成了 X1 和 X2)。
隐藏层:在被称为前向传播的过程中，输入层数据被传输到隐藏层中的 4 个节点中的每一个。你在隐藏后选择的节点数量很重要；节点太少，您的模型可能会不足，节点太多，您的模型可能会过拟合，运行缓慢。根据 StackExchange 帖子中解释的信息，我们将为隐藏层选择 4 个节点。
输出层:隐藏层的信息随后被传输到输出层，以进行我们的最终预测(即，点是蓝色还是红色？).这是通过完成本文后面提到的一些步骤(估计成本、反向传播和更新我们的参数)来实现的。
因此，让我们创建这 3 层现在与他们相应的节点数量。
def layer_sizes(X, Y):
"""Takes the arguments:
X = shape of feature variable data
Y = shape of the output data
Returns:
n_x = input layer size
n_h = hidden layer size
n_y = output layer size"""
n_x = X.shape[0]
n_h = 4
n_y = Y.shape[0]
return(n_x, n_h, n_y)(n_x, n_h, n_y) = layer_sizes(X, Y)print("The size of the input layer is: n_x = " + str(n_x))
print("The size of the hidden layer is: n_h = " + str(n_h))
print("The size of the output layer is: n_y = " + str(n_y))
其输出是:
神经网络的层和节点(图片由作者提供)
第二步。初始化参数
现在我们已经定义了我们的网络结构，我们需要考虑构建将输入层数据传输到隐藏层的函数，以启动神经网络过程。然而，这些函数包含我们必须初始化(即设置值)的术语(称为参数)。
这是我们将在步骤 3 中使用的第一个函数。正向传播):
前向传播中使用的基本线性函数
在这个函数中，我们已经有了我们的输入数据 x 、该数据的权重(重要性) w 和我们的偏差项 b 。 w 和 b 为参数。因为我们还没有参数的值，所以我们必须初始化它们。
我们如何以及为什么初始化这些参数与梯度下降有很大关系，梯度下降是神经网络行为的核心组成部分。所以让我们简单地聊一聊。
梯度下降(快速注释)
像许多非确定性模型一样，神经网络在随机梯度下降的前提下运行。在训练期间，这些算法采取增量步骤来最小化成本——反映模型整体表现如何的单个值(即预测值和实际值之间的误差)。他们采取的“学习步骤”取决于我们的 w (权重)和 b (偏差)。
对于我们的模型，我们想要尽可能低的成本。将梯度下降过程想象成一个球滚下山坡，试图找到最低点(成本)。
梯度下降可视化(作者图片)
在好的(不太好的)模型中，成本可能会停留在起点的较低点(局部最小值)，但不会处于绝对低点(全局最小值)。因此，因为我们(1)无法提前可视化我们的搜索空间，并且(2)不想以次优成本“困住”我们的模型，所以一个好的方法是用随机值初始化我们的参数 w (权重)和 b (偏差)。这确保了梯度下降从任何地方开始，而不会注入我们自己的偏见。
其次，我们希望参数的值小一些，例如，大约 0.01。我们的选择有点像金发姑娘。太大的值和成本将在最小值附近振荡太多(即“爆炸梯度问题”)，零值基本上阻止我们的梯度更新任何权重。这被称为“未能打破对称性”，是神经元计算类似输出的结果，阻止了独立学习，并从本质上抵消了神经网络的优势。
我们需要初始化的参数将跨越输入层到隐藏层(称它们为 W1 和 b1 )，然后隐藏层到输出层(称它们为 W2 和 b2 )。正如我们上面提到的，我们将把它们初始化为随机的小值。注意，偏置项 b1 和 b2 是向量，因为它们是通过广播加到 w*x 乘积上的，所以可以用大小为 1 的列初始化为零。
def initialize_parameters(n_x, n_h, n_y):
"""Initialize the parameters for weight matrix w1, w2 and bias vectors b1, b2.
Where:
n_x -- size of the input layer
n_h -- size of the hidden layer
n_y -- size of the output layer
Returns:
params -- python dictionary containing your parameters:
W1 -- weight matrix of shape (n_h, n_x)
b1 -- bias vector of shape (n_h, 1)
W2 -- weight matrix of shape (n_y, n_h)
b2 -- bias vector of shape (n_y, 1)
"""
np.random.seed(2)
W1 = np.random.randn(n_h, n_x) * 0.01
b1 = np.zeros((n_h, 1))
W2 = np.random.randn(n_y, n_h) * 0.01
b2 = np.zeros((n_y, 1))
assert (W1.shape == (n_h, n_x))
assert (b1.shape == (n_h, 1))
assert (W2.shape == (n_y, n_h))
assert (b2.shape == (n_y, 1))
parameters = {'W1': W1,
'b1': b1,
'W2': W2,
'b2': b2}
return parameters
让我们看看这些参数会是什么样子:
parameters = initialize_parameters(n_x, n_h, n_y)
print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))
退货:
用随机的小值初始化权重(图片由作者提供)
步骤 3:正向传播
初始化参数后，我们现在可以实现如上所述的线性函数( z = w * x + b )。然而，单独的线性函数只会产生一个执行类似于逻辑或线性回归的神经网络。因此，我们还必须将我们的 z 输出传递给被称为激活函数的非线性函数。
这里的直觉是，我们有一个带有非线性决策边界的嘈杂数据集，那么为什么要应用线性模型呢？正是这些非线性激活函数将采取额外的步骤来转换我们的线性函数的输出( z = w * x + b )，以便更好地对我们的非线性数据进行分类。
我们可以在神经网络中使用多种激活函数，每种都有自己的优缺点。对于我们的神经网络，我们将在隐藏层选择一个 tanh 激活函数，在输出层选择一个 sigmoid 激活函数。Tanh 计算-1 和 1 之间的输出，激活的平均值为零。这具有自然地使我们的数据居中的效果，这允许在隐藏层之间学习以更快地计算。Sigmoid 在输出层非常理想，特别是对于二进制分类问题，因为它计算 0 和 1 之间的输出。
如果我们的 z 输入非常大或非常小，那么 sigmoid 和 tanh 都有轻微的缺点；梯度(或斜率)变得非常小(有时接近零),可以减缓梯度下降。
1-隐层神经网络的 z 和激活函数(图片由作者提供)
让我们从上面显示的 4 个函数中解开细节。
- 第一个线性 z[1] 函数计算所有输入层数据 a[0] (一种表示我们所有 X 特征数据的方式)和输入层权重 W[1] 的乘积，并添加所有输入层偏差项b[1】。
- 激活函数 a[1] 是 z[1] 输出的双曲正切函数。
- 第二个线性z【2】函数计算所有隐藏层数据a【1】(一种表示我们所有初始激活函数的方式)和隐藏层权重W【2】的乘积，并添加所有隐藏层偏差项b【2】。
- 激活函数 a[2] 是 z[2] 输出的 sigmoid 函数。
我们可以为z【1】a【1】z【2】和a【2】编写上述函数。然后我们可以将这些值存储到一个名为“cache”的字典中，以备后用。
def forward_propagation(X, parameters):
"""Forward propagation will compute activations functions for
the hidden and output layer, producting outputs A1 and A2.
Arguments: Takes X data and parameter variables (W1, W2, b1, b2)
"""
#retrieve each of the paramters from the dictionary
W1 = parameters['W1']
b1 = parameters['b1']
W2 = parameters['W2']
b2 = parameters['b2']
Z1 = np.dot(W1,X) + b1
A1 = np.tanh(Z1)
Z2 = np.dot(W2, A1) + b2
A2 = sigmoid(Z2)
cache = {"Z1": Z1,
"A1": A1,
"Z2": Z2,
"A2": A2}
return A2, cache
现在我们已经在缓存中定义了线性 Z 函数( z[1] 、 z[2] )和激活函数( a[1] 、 a[2] )，以备后用。
干得好，走了这么远！我们已经学会了如何创建一个神经网络结构，初始化参数，实现一些激活功能，是的，甚至还学了一点数学。
在本帖的第 2 部分 中，我们将介绍构建神经网络模型的其余步骤:(4)定义成本，(5)实现反向传播，(6)更新参数，以及(7)进行预测。
设计基本神经网络的 7 个步骤(第 2 部分，共 2 部分)
一个数学不太密集的，一步一步的指南，从头开始建立一个隐层神经网络
图片由 Lindsay Henwood 在 Unsplash 上提供
在本部分的第 1 部分(共 2 部分)中，我们看到了使用传统预测模型(如逻辑回归)来正确分类嘈杂数据集中的两种颜色的局限性。然后，我们建立自己的神经网络结构，初始化参数，并计算前向传播激活函数。
在第 2 部分中，我们将完成神经网络模型的构建，以更好地对原始数据集中的色点进行分类。具体来说，我们将回顾成本函数、反向传播、参数更新和最终的模型装配/预测。
第四步:估算成本
我们之前讨论了在我们的神经网络模型中最小化成本的重要性。事实证明，成本函数从我们的正向传播和原始的 Y 输出中获取我们已经知道的变量——a[2]。
带有变量 A2 和 Y 的成本函数(图片由作者提供)
回想一下a【2】是输出层最后的激活函数输出。上面的 m 变量仅仅是我们原始数据集中的观察数量。下面是向前传播的视觉示意图，供您回忆。
1-隐层神经网络的 z 和激活函数(图片由作者提供)
因此，将这个成本等式转换为 python，我们可以使用 np.dot 来计算乘积，使用 np.log 来计算对数。让我们现在做那件事。
def compute_cost(A2, Y, parameters):
"""Computes cost using the cost function, where logprobs is actually the loss.
Arguments: Takes A2 output, Y and parameters.
Returns: cost"""
# m is the number of total observations
m = Y.shape[1]
# logprobs is the loss, which we can use to compute the cost
logprobs = np.multiply(np.log(A2), Y) + np.multiply((1-Y),np.log(1-A2))
cost = (1./m) * -np.sum(logprobs)
cost = float(np.squeeze(cost))
assert(isinstance(cost, float))
return cost
如果我们现在跑:
cost(A2, Y, parameters)
我们返回 0.693 的成本，这不是很大，但只是我们在梯度下降的初始进入点(0 次迭代后)的成本。反向传播将通过多次迭代来降低成本。让我们看看怎么做。
步骤 5:反向传播
反向传播在数学上非常密集。有很多很棒的文章回顾了偏导数微积分。但从概念上讲，我们通过网络反向传播关于我们误差的信息，以调整我们的初始参数和微调我们的权重。经过多次迭代，我们每次都逐渐降低成本。这一过程优化了我们的模型，使其更具普遍性。
当我们在各层中向后移动时，首先计算最后一层权重的梯度，最后计算第一层权重。来自一层的部分计算(即偏导数)被传递到下一层。这允许错误信息反向流动。
在前向传播中我们计算了 z1 、 w1 、 b1 和 z2 、 w2 和 b2 ，在后向传播中我们将计算 dz1 、 dw1 、 db1 和 dz2 、 dw2 和DB2
def backward_propagation(parameters, cache, X, Y):
"""Computes backward propagation.
Arguments: Takes parameters, cache (z1, a1, z2, a2), X and Y.
Recall:
Parameters - w1, b1, w2, b2
X -- input data of shape (2, number of examples)
Y -- "true" labels vector of shape (1, number of examples)
Returns:
grads -- dictionary containing your gradients with respect to different parameters.
"""
m = X.shape[1]
# First, retrieve W1 and W2 from the dictionary "parameters".
W1 = parameters["W1"]
W2 = parameters["W2"]
# Retrieve also A1 and A2 from dictionary "cache".
A1 = cache["A1"]
A2 = cache["A2"]
# Backward propagation: calculate dW1, db1, dW2, db2\.
dZ2 = A2 - Y
dW2 = (1./m) * np.dot(dZ2, A1.T)
db2 = (1./m) * np.sum(dZ2, axis=1, keepdims=True)
dZ1 = np.dot(W2.T, dZ2) * (1 - np.power(A1, 2))
dW1 = (1./m) * np.dot(dZ1, X.T)
db1 = (1./m) *(np.sum(dZ1,axis = 1,keepdims = True))
grads = {"dW1": dW1,
"db1": db1,
"dW2": dW2,
"db2": db2}
return grads
我们刚刚创建的 grad 字典包含导数参数，我们将在下一步中使用学习率更新这些参数。
第六步:更新参数
为了更新我们的原始参数( w1 、 b1 、 w2 、 b2 )，我们计算学习率和我们先前在反向传播中计算的每个导数参数的乘积。然后我们从原始参数中减去这些值。这显示在下面的 python 代码中。
def update_parameters(parameters, grads, learning_rate = 1.5):
"""Computes updates to our original parameters using a predefined learning rate.
Arugments: Takes parameters, grads, learning_rate (you can set)
Outputs: New parameters """
# utilize pre-existing parameters for weights and bias vectors
W1 = parameters['W1']
b1 = parameters['b1']
W2 = parameters['W2']
b2 = parameters['b2']
# Retrieve each parameter from the dictionary "parameters"
dW1 = grads['dW1']
db1 = grads['db1']
dW2 = grads['dW2']
db2 = grads['db2']
# update rule for each parameter
W1 = W1 - learning_rate * dW1
b1 = b1 - learning_rate * db1
W2 = W2 - learning_rate * dW2
b2 = b2 - learning_rate * db2
parameters = {'W1': W1,
'b1': b1,
'W2': W2,
'b2': b2}
return parameters
看看更新后的参数:
parameters = update_parameters(parameters, grads)print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))
原始参数现已更新(图片由作者提供)
步骤 7:模型装配/预测
在最后一步中，我们将组合并运行我们之前的所有函数 10，000 次迭代，试图降低我们的总成本，并以最低的成本返回最佳参数。
def model_nn(X, Y, n_h, num_iterations = 10000, print_cost = True):
np.random.seed(5)
# define input and output layer shape
n_x = layer_sizes(X, Y)[0]
n_y = layer_sizes(X, Y)[2]
# define the parameters
parameters = initialize_parameters(n_x, n_h, n_y)
W1 = parameters["W1"]
b1 = parameters["b1"]
W2 = parameters["W2"]
b2 = parameters["b2"]
# compute gradient descent for specified number of iterations
for i in range(0, num_iterations):
# forward propagation
A2, cache = forward_propagation(X, parameters)
# cost
cost = compute_cost(A2, Y, parameters)
# backpropagation
grads = backward_propagation(parameters, cache, X, Y)
# Gradient descent parameter update. Inputs: "parameters, grads". Outputs: "parameters".
parameters = update_parameters(parameters, grads)
# Print the cost every 1000 iterations
if print_cost and i % 1000 == 0:
print ("Cost after iteration %i: %f" %(i, cost))
return parameters
当我们运行这段代码时，我们可以看到成本随着每 1，000 次迭代而下降，直到大约为 0.094，这比我们最初的 0.693 成本有了很大的提高。
model_nn(X, Y, n_h, num_iterations = 10000, print_cost = True)
10，000 次迭代后的成本(图片由作者提供)
然后，我们使用参数(与最低成本相关联)来更准确地对初始数据集中呈现的点颜色进行分类。为此，我们将再次运行正向传播步骤来计算最终的 A2 输出，并使用 0.5 作为阈值来确定预测应该是 0 还是 1。
def predict(parameters, X):
"""Takes learned parameters to predict each class in X
Arguments: Takes parameters, and X
Outputs: Prediction values -- vector of predictions in our model (red: 0 / blue: 1)
"""
# Computes forward propagation again to determine probabilities
# Classifies to 0/1 using 0.5 as the threshold.
A2, cache = forward_propagation(X, parameters)
predictions = (A2 > 0.5)
return predictions
通过 10，000 次迭代应用我们的最终模型(model_nn ),我们可以再次生成要在决策边界图中使用的那些参数。
# Build a model with a n_h-dimensional hidden layer
parameters = model_nn(X, Y, n_h = 4, num_iterations = 10000, print_cost=True)# Plot the decision boundary
plot_decision_boundary(lambda x: predict(parameters, x.T), X, Y)
plt.title("Decision Boundary for hidden layer size " + str(4))
改进了原始数据集的决策界限(图片由作者提供)
正如我们所看到的，我们的神经网络工作在正确地将点分类为红色或蓝色方面做得更好。打印我们的预测值和真实值之间的准确度分数，发现准确度确实是 96%。
# Print accuracy
new_predictions = predict(parameters, X)
print ('Accuracy: %d' % float((np.dot(Y,new_predictions.T) +
np.dot(1-Y,1-new_predictions.T))/float(Y.size)*100) + '%')
我希望这篇由两部分组成的文章提供了丰富的信息。如果你刚刚开始你的神经网络之旅，我强烈推荐吴恩达的 Coursera 讲座。它们是我撰写本文的灵感来源，并帮助我巩固了其中的许多概念。下次见！
打造自己 Dockerhub 形象的 7 个步骤
通过 Dockerhub 与他人分享您的 Python 代码
将代码打包用于生产的最简单的方法是使用容器映像。DokerHub 就像是容器图像的 Github 你可以免费上传和与他人分享无限量的公开可用的 dockerized 应用程序。在本文中，我们将构建一个简单的图像并将其推送到 Dockerhub。
1.注册一个免费的 Dockerhub 帐户
注册屏幕-作者图片
你选择的 Docker ID 很重要，因为你需要用它来标记你所有的图片。例如，如果您的 Docker ID 是ml-从业者，那么您的所有图像都必须在表格中进行标记:
ml-practitioner/image-name:latest
如果要创建容器映像的多个版本，可以用不同的版本标记它们，例如:
mlpractitioner/mydatascienceimage:1.2
2.创建 Dockerfile 文件
一个Dockerfile包含一组 Docker 映像的指令。你可以把它想象成一个蛋糕的配方。一旦你在 Dockerhub 上建立并分享了你的形象，就像在你的烹饪博客上与他人分享你策划的食谱一样。然后，任何人都可以使用这个精心准备的食谱(您的 Dockerhub 图像)，或者直接在此基础上烘焙一个蛋糕(按原样从该图像运行一个容器实例)，或者进行一些修改并创建更好的食谱(将其用于其他 Docker 图像)。
事实上，在下面这个简单的 Dockerfile 例子中，我们正在这样做:我们使用一个图像python:3.8作为基础图像(基础配方)，并且我们正在用它创建我们自己的图像，这具有向基础图像添加新层的效果:
COPY命令将你的文件复制到容器目录中，CMD决定了通过docker run image-name启动容器时执行的代码。
3.建立你的码头工人形象
这么说吧，我的形象就叫etlexample。在我们的终端中，我们切换到目录，在那里我们有 Dockerfile、requirements.txt 和包含我们的主代码的src目录(可以包含几个模块)。
让我们构建一个简单的 ETL 示例。下面是我们将使用的项目结构:
您的requirements.txt可能如下所示(只是一个例子):
然后我们需要建立我们的形象:
docker build -t etlexample .
末尾的点表示构建上下文——对我们来说，这意味着我们使用当前工作目录中的Dockerfile进行构建。
现在你的图像准备好了！当你输入docker image ls，你应该能看到你的图像。
4.从您的终端登录 Dockerhub
docker login -u myusername
myusername表示我们注册时选择的 Docker ID。然后会提示您输入密码。然后，你应该看到:Login succeeded。
5.标记您的图像
默认情况下，当我们构建一个图像时，它会分配标签latest,意思就是图像的“默认版本”。当标记时，你可以给它分配一些特定的版本。现在，我们将使用latest标签。
docker image tag etlexample:latest myusername/etlexample:latest
当您现在再次键入docker image ls时，您将看到带有您的 Dockerhub 用户名的图像。
6.将您的图像推送到 Dockerhub
docker image push myusername/etlexample:latest
7.测试并确认成功
当您现在尝试提取此图像时，您应该会看到:
结论
在这篇短文中，我们研究了构建新映像并将其推送到 Dockerhub 所需的步骤。确保不包含任何敏感信息——避免任何硬编码的凭证或任何您不想在公共 Github 帐户中以相同方式共享的代码。
感谢您的阅读！如果这篇文章对你有用，请 关注我的 来看看我的下一篇文章。
参考资料&其他资源:
要提升的 7 个语法模式🚀你的黑客等级🐍Python 编码挑战
这也帮助我在 3 周内清除了所有的 Hackerrank 挑战
照片由 Fotis Fotopoulos 在 Unsplash 上拍摄
动机😎
D 迎接编码挑战可能是快速学习编程语言实用方面的最好方法。与做实际项目相比，它更侧重于利用特定的语言概念和语法来提高你解决问题的技能。这是深度(项目)对广度(编码挑战)。
当你也阅读其他人的解决方案和评论时，你会从中受益更多。你会发现不同的思维方式，不同的语言技巧被用来解决同一个问题，并通过多次练习快速掌握它们。我认为每个想要使用特定编程语言作为主要开发工具的人都应该至少清除一次 Hackerrank 上的所有编码挑战。
我以前很难读懂别人用 Python 写的代码，但在我用 Python 清除了 HackerRank 上的挑战后，我就没有这个问题了。
在这篇文章中，我将记录我一路走来所学到的东西，希望它能让你的旅程更加顺利。我们开始吧！
获得正确的问题输入
信不信由你，像这样一件简单的事情会大大提高你的生活质量。所有 HackerRank 挑战都使用stdin作为输入，并期望你输出正确答案给stdout。当您到达 Hackerrank Python 之旅的终点时，以下片段会感觉相对琐碎。但是当你刚刚起步的时候，抓住这些会让最初的几步变得容易得多。另外，**map** 功能和列表理解也是很好的练习:
1。将一行**n**数字放入一个列表: list(map(int, input().strip().split()))
2。n, m = input(), input()得到两个整数:
3。将一行字符串放入列表:list(input().strip().split())
4 .获取一个将**n** 行作为 int: a = np.array(input().strip().split(), int) for _ in range(n) ]的 NumPy 数组
(嵌套)列表理解
里卡多·戈麦斯·安吉尔在 Unsplash 上拍摄的照片
嗯，列表理解并不是什么新鲜事。我们都喜欢它的简洁和表现力。你会在挑战中大量使用。列表理解更具挑战性的部分是钉钉'嵌套'部分，尤其是再加上**if** 语句。最简单的方法是像写**for-loop**一样写，然后转化为列表理解。考虑以下三层深度嵌套 for 循环的条件:
作者使用 manim 制作的动画
如何把它变成一个列表理解的一句话？这比你想象的要容易。只需将每一行一个接一个地向上拖动成一行，然后将最里面的块**lst.append([i,j,k])**放在最左边的位置(该行的开始)，就像这样:
[**[i,j,k]** for i in range(x) for j in range(y) for k in range(z) if i > j and j > k]
正如 Python PEP 202 所述:
建议允许使用 for 和 if 子句有条件地构造列表文字。它们会以同样的方式嵌套循环和 if 语句。****
如果你读到这里，那么恭喜你！您已经掌握了嵌套列表理解的艺术！你也可以在这里找到一篇好文章。
使用'getattr' '来访问类函数
加里·巴特菲尔德在 Unsplash 上拍摄的照片
ackerrank Python 挑战赛有时是为了教你如何使用某些数据结构，比如集合和集合。这种类型的问题通常会有数据结构的多个函数的输入，并让你一个一个地尝试。对于这类问题，使用**if/elif/else**会非常麻烦。在这里，我建议一种更好的方法，使用**getattr**来访问特定于数据结构的函数。这样，你就不需要写多行**if/elif/else**，只需要一个**getattr**单行程序。我们来看一个的例子 :
这个问题需要你得到集合命令**update**、**intersection_update**、**difference_update**等。，然后使用它来操作所提供的集合，以获得所需的结果。你当然可以用**if/elif**做到这一点，但是请看下面的片段:
# A is the set provided
(_, A) = (int(input()),set(map(int, input().split()))) # B is the number of commands to test
B = int(input())
for _ in range(B):
# get the command and parameter
(command, newSet) = (input().split()[0], set(map(int, input().split()))) # ‘getattr’ one-liner, yay 🎆
getattr(A, command)(newSet)
print (sum(A))
它的优点是从输入中读取的命令可以直接用于访问 set 命令，因此是一行程序。这个技巧可以用在多种挑战上，节省你相当多的时间，同时让你对函数式编程有一点了解。你也可以像这样使用**eval**:eval(“A.”+op+”(B)”)，但据说这不太稳定，通常推荐使用**getattr** 而不是**eval**。
使用 all()和 any()进行布尔列表聚合
T he **and()**和**any()**内置在 Python 中并不新鲜，但是意识到使用它是一个需要养成的好习惯。它允许你更抽象地思考，让你的代码更简洁。作为良好的布尔迭代器聚合器，它们使您能够在一行代码中检查一长串的**and** 或**or** 条件。此外，如果你碰巧也从事数据科学/机器学习，让自己适应聚合从长远来看将有利于你的旅程。例如，在机器学习中，你会进行大量的数组计算。你可以用类似于for-loop的东西来做这件事，但是把数据聚集成一个矩阵，尽可能地集中处理它们，将会大大减少你的计算时间。你越早进入这种思维方式，计算(和时间)就越多⏲还有钱💸连同它)你将能够保存。
排序()和已排序()的“关键字”。
Silas k hler 在 Unsplash 上拍摄的照片
U 唱**sort()**和**sorted()**不是很有挑战性。然而，没有太多人意识到它的全部潜力。这🔑键是用**key** 论证。(双关意！).当使用**sort()**或**sorted()**时，您可以添加一个参数**key** ，该参数期望一个函数被传递给它，然后该函数将被用于为排序生成值。这使得排序更加灵活和强大。你可以使用它对你的物品做各种事情。几个想法:
1。key = len；使用字符串、列表等的长度。，来做排序。
2。key = str.lower；将字符串全部转换成小写，然后排序。这使得排序不区分大小写。
3。key = lambda x: x[::-1]；恢复字符串的顺序，然后排序。
4。key = lambda x: int(x.split()[K])；挑选出 iterable 的**k**列，因为要排序的值可能会在类似表格的数据处理中使用。
5。key = lambda x: (item1, item2, item3, …, item_n)；这里有**item1**、**item2**等。都是 x 的变体，所以可以做嵌套排序。如你所见，这里的潜力是无限的。在这里使用**key** 论点的唯一限制是我们自己的创造力。如果想了解更多，可以查看这篇文章。
arg 和kwargs 无处不在！*
我们通常在函数参数中使用***args**和****kwargs**。从 Python 3.5 版本开始，使用 PEP 448 作为解包操作符，它变得更加强大。它可以将任何迭代器解包到它的所有项中。单星号操作符*****可以用在 Python 提供的任何 iterable 上，而双星号操作符******只能用在字典上。
在 Hackerrank challenges 中，它通常与**print** 函数一起使用来解包要打印的 iterable。例如，如果您有一个列表:
lst = [‘May’, ‘the’, ‘force’, ‘be’, ‘with’, ‘you.’]
把这个打印成句子的一种方法是:print(‘ ‘.join(lst))，或者你可以只做**print(*lst)**。
另一个好玩的用法是解包一个字符串，比如说str = “Stay a while and listen.”，可以做**list(str)**，也可以做***str**得到[‘S’, ‘t’, ‘a’, ‘y’, ‘ ‘, ‘a’, ‘w’, ‘h’, ‘i’, ‘l’, ‘e’, ‘ ‘, ‘a’, ’n’, ‘d’, ‘ ‘, ‘l’, ‘i’, ‘s’, ‘t’, ‘e’, ’n’, ‘.’]。
它还有很多其他的用途，意识到这一点会让你更快地通过挑战。
正则表达式—前视/后视断言
在 Hackerrank 中有很多挑战。三分之二的 Python“硬”挑战是正则表达式挑战。Hackerrank 中复杂正则表达式问题的关键？我提供两种配料:
用非捕获组匹配处理非重叠匹配
有时，挑战要求您匹配重叠的模式，比如说，如果要求您在字符串“3333”中找到所有的“33”。你应该找到其中的 3 个，但如果你只用r'33'，你只会找到两个，因为前两个‘33’会被‘消耗/捕获’。这就是非捕捉组可以大放异彩的地方。使用(?:<regex>)，您可以轻松地捕获一个模式组，而无需“消耗”它，从而允许捕获所有不重叠的匹配。对于我们的“3333”案例，我们可以使用r’(?:33)’来查找所有三个匹配。另外两个有用的是Lookahead和Lookbehind断言。用法挺像的。你可以点击查看文章了解更多详情。
使用\1 查找重复的匹配组
这是一个简单的方法，但在 Python 挑战中被多次使用。考虑下面的例子:
m = re.search(r’(\d)\1{3}’, ‘4444–5555’)
这将匹配‘4444’和‘5555’。r’(\w+),\1,\1'将匹配“走，走，走”或“不，不，不”。
Regex 本身可能非常复杂，我发现将它们分成几个步骤并逐个解决它们很有帮助。
结论
以上片段绝非包罗万象。然而，我发现它们有助于加快速度。此外，其中一些是需要养成的好习惯，是需要建立的良好心态，从长远来看，这将有利于您的编码之旅。祝你好运，编码快乐！
我希望你觉得这篇文章读起来很有趣，并从中学习到一些东西。如果你想更多地了解我对数据科学的思考、实践和写作，可以考虑报名成为 Medium 会员。每月 5 美元，你可以无限制地阅读媒体上的故事。如果你注册使用我的链接，我会赚一小笔佣金。
**https://lymenlee.medium.com/membership **
每个数据科学家都应该知道的处理多重共线性的 7 种技巧
检测和处理数据集中多重共线性的基本指南
探索性数据分析和统计分析是数据科学模型开发流程中的重要组成部分，用于生成关于数据的见解。在拟合机器学习模型之前，数据科学家需要执行各种特征工程和数据预处理技术来训练稳健的模型。处理数据集中的多重共线性就是这样一种要素工程技术，在拟合模型之前必须加以注意。
什么是多重共线性？
多重共线性是指两个或多个独立要素相互关联的情况。其中一个共线要素的更改可能会影响其他相关要素。数据集中的多重共线性可能是由于收集数据时的实验设计不当造成的，也可能是在创建新要素时引入的。
多重共线性可能导致训练回归模型后系数不稳定。相关特征的存在可能不会给模型增加任何新的有价值的信息。
在对数据集建模之前，需要检测并处理多重共线性的情况。有多种技术可以检测和处理多重共线性的情况，我们将在本文中讨论其中一些技术。
1.)相关矩阵:
我们有各种统计技术来衡量两个特征之间的相关性。可以为数据集形成表示每对特征之间的相关值的相关矩阵。相关矩阵只能测量两个要素之间的共线性，而不能检测数据集中的多重共线性。
有各种相关系数技术，包括 spearman 相关、Spearman 相关、Kendall 相关、Cramer’s V 相关、卡方检验等等。Pandas 库提供了使用**Dataframe.corr(method=‘pearson’)**函数实现相关矩阵的 API。方法超参数中的“pearson”输入可以替换为“kendall”和“spearman”。
现在问题来了，哪种统计相关算法可以用于各种条件。下表描述了在什么条件下使用哪种相关技术:
(图片由作者提供)，
2.)差异通货膨胀因素(VIF):
相关矩阵仅适用于检测两个要素之间的共线性，但在检测要素的多重共线性时，它会失败。VIF 是另一种可用于检测要素多重共线性的技术。
VIF 通过计算 R 平方度量来测量要素的多重共线性。
(图片由作者提供)，特征“I”的 VIF 计算公式
(图片由作者提供)，R 平方度量公式
r 平方度量衡量数据点拟合直线或曲线的程度。它的范围在 0 和 1 之间，其中接近 1 的值反映了一个好的模型。
计算每个特征的 VIF 值，其中训练回归模型，保持一个特征作为因变量，其他特征作为独立特征。
VIF 数值的实值范围为 1 到无穷大，其中值 1 表示给定要素不存在多重共线性。随着 VIF 值向上增加 1，要素之间存在的多重共线性越多。通常，标准的经验法则是:
- VIF=1:无多重共线性
- VIF 在 1 到 5 之间:中度多重共线性
- VIF > 5:高度多重共线性
3.)拉索回归:
套索回归是一种以 L1 先验为正则项的线性回归技术。其思想是通过正则化来减少多重共线性，即减少多重共线性要素的系数。
通过增加 L1 正则化的α值，我们在估计器中引入了一些小的偏差，打破了相关性并减少了方差。
Scikit-learn 包提供了在一行 Python 代码中执行套索回归的 API。
关于套索回归的实现，参见 scikit-learn 文档。
4.)主成分分析(PCA):
PCA 是一种降维技术，它使用矩阵分解来计算特征值和特征向量。PCA 基于特征向量将给定的数据集投影到新的维度空间。
PCA 可用于处理数据集中的多重共线性，方法是采用保留最大方差的顶部特征向量。可以通过观察为每个特征向量保留的方差来决定维数。
跟随 Bhawesh Bhatt 的这本 ipynb 笔记本，更好地理解 PCA 处理多重共线性的实现。
5.)分层聚类:
层次聚类是一种基于某种相似性标准对相似的对象聚类进行分组的聚类算法。有两种类型的分层聚类算法:
- 凝聚聚类:顺序合并相似的聚类
- 分裂聚类:按顺序划分不相似的聚类
要处理多重共线性，需要对 spearman 等级顺序系数执行等级聚类，并根据阈值从每个聚类中选取一个要素。阈值的值可以通过观察树状图来确定。
遵循 scikit-learn 文档实施上述想法。
6.)分类要素的多重共线性:
pd.get_dummies() ， OneHotEncoder() 是对一键编码格式的分类特征进行矢量化的函数。对任何分类要素进行一次性编码时，都会在数据集中引入多重共线性。
基本思想是从一次性编码的矢量化数据中移除一个要素级别，以处理多重共线性的情况。pd.get_dummies()函数有一个可设置为 True 的参数 drop_first，用于从矢量化中移除第一个特征值。类似地，一键编码器的 scikit-learn 实现提供了可以删除一个特性的 drop 参数。
7.)更多数据:
向现有数据集添加更多数据可以打破多重共线性模式。这种技术通常有助于消除多重共线性问题。
结论:
在本文中，我们讨论了处理多重共线性情况的各种技术。相关矩阵和 VIF 技术可以检测多重共线性特征，但是数据科学家需要去除决定系数阈值的特征。可以调整 Lasso 回归的 alpha 值以减少多重共线性。
参考资料:
[1] Scikit-learn 文档:https://sci kit-learn . org/stable/auto _ examples/inspection/plot _ permutation _ importance _ multicollinear . html
喜欢这篇文章吗？成为 中等会员 继续无限制学习。如果你使用下面的链接，我会收到你的一小部分会员费，不需要你额外付费。
https://satyam-kumar.medium.com/membership
感谢您的阅读
你需要提高你的 Python 水平的 7 个信号
避免这些常见的不良做法和新手错误
在以下七种说法中，你能认出自己吗？那么这个故事是给你的！
- 您正在使用
sys或os进行文件路径管理 - 你正在用
.format()或% operator格式化字符串 - 你没有使用
typing类型提示 - 你没有使用
lambda的显式熊猫功能 - 你是
printing而不是logging用户反馈 - 您没有使用 linters 或 formatters，也没有使用
pre-commit - 你没有使用
ifmain
是时候用下面的小技巧&把你的 Python 2.x 知识升级到 Python 3.10 了。
Pathlib:一种更好的路径处理方式
忘记
sys和os，用pathlib代替。
Python 3.4 引入了内置库pathlib，它将字符串路径转换为面向对象的文件系统路径，启用属性和方法功能。从 PEP519 开始，pathlib是公认的 Python 文件路径的抽象。
用 f 字符串格式化字符串
忘记
% operator和.format()，用*f''*代替。
Python 3.6+引入了对字符串格式的最新更新:f-strings。
类型提示
使用类型提示增加源代码文档和可读性。
从 Python 3.5+开始，我们已经看到了下一代代码文档:提示哪些变量的类型在函数或类参数和返回语句中。这使得格式化程序、linters 和 IDE 能够为类型检查提供运行时支持。
类型提示可以从typing模块导入。格式为<variable name> : <variable type>，可以直接插入函数参数中。您可以用-> <return variable>包含返回声明。
请注意，类型提示是可选的:Python 解释器完全忽略它们，带有错误格式的类型提示的 Python 代码仍然会运行。像 Pycharm 这样的 ide 集成了类型检查，而像mypy这样的静态类型检查工具可以将类型错误作为 bug 挖掘出来。
熊猫:使用 lambda 函数
忘记隐式过滤和列赋值，改用
lambda。
Pandas 是一个很棒的库，已经成为任何数据科学项目的标准。但是要确保明智地使用它的功能。避免常见的不良行为，例如:
- 没有
.loc和lambda函数的隐式滤波。 - 没有
.assign和lambda函数的隐式列赋值。
虽然这些方法有效，但是它们很难维护，尤其是在链接选项时。显式比隐式好:用指定的方法指定你在做什么，比如.loc或.assign和如何用lambda函数。lambda函数是未命名的函数，在这种情况下，迭代熊猫DataFrames的行。
日志:用于反馈的内置模块
忘记
print()，使用logging进行错误、警告和调试。
打印错误可能对调试有用，但是使用 Python 内置的[logging](https://docs.python.org/3/library/logging.html)模块使所有的 Python 模块都能够参与日志记录，因此您的应用程序日志可以包含您的消息以及来自第三方模块的消息。
logging模块提供了从最不严重到最严重的几个LEVELS:
DEBUG—详细信息，通常仅在诊断问题时感兴趣。INFO—确认事情按预期运行。WARNING—表示发生了或即将发生意想不到的事情(如“磁盘空间不足”)。该软件仍按预期工作。ERROR—由于更严重的问题，软件无法执行某些功能。CRITICAL—严重错误，表示程序本身可能无法继续运行。
basicConfig的级别表示要包含哪些日志。例如，如果您使用info()，但是日志级别被设置为WARNING，这些日志就不会显示出来。您也可以使用配置将日志输出到一个example.log文件，而不是将我们的日志流式传输到标准输出(相当于打印它们):
logging.basicConfig(filename='example.log',level=logging.DEBUG)
预提交:自动林挺和格式化
再也不要手动检查 Python 源代码中的样式错误。
通过 Git 挂钩，我们可以在每次提交和推送到我们的库之前运行林挺和格式化工具，比如mypy、autoflake、flake8、isort、black。这使我们能够在 Python 项目中自动创建标准化的代码风格约定。这些 Git 挂钩由pre-commit包提供。请在下面的故事中找到更多关于预提交 Git 挂钩的有用提示👇
https://betterprogramming.pub/4-tips-to-automate-clean-code-in-python-527f59b5fe4e
Ifmain:模块化 Python 代码
通过
__main__执行脚本，通过__module_name__执行模块。
当 Python 解释器解析 Python 脚本时，设置一些顶级变量并执行源代码。为了避免执行.py文件中的所有源代码，我们将ifmain与顶层__name__变量结合使用。该__name__变量是
__main__执行源文件时，像这样:$ python3 file.py- 导入模块时的模块名称
__module_name__如下:import modular_function from file.py
if __name__ == '__main__':下的ifmain代码是样板代码，保护用户在无意中调用脚本中的源代码。导入使用命令行参数和argparse的无保护脚本的一个问题是 CLI 参数会被覆盖。
An ifmain是 Python 中模块化编码原则的一部分:不要重复自己(干)。它使您能够编写独立的函数，这些函数独立于.py文件中的其余代码运行，同时也能够将源代码作为主程序运行。
在你的日常工作中使用这七个技巧，至少在接下来的几个月里，你就是未来的证明😉编码快乐！
https://medium.com/analytics-vidhya/seven-tips-to-clean-code-with-python-24930d35927f
开始数据科学训练营之前要做的 7 件事
我刚刚从激励数据科学沉浸式训练营毕业。在这个数据科学训练营中，我们花了 3 个月时间学习统计学、线性代数、微积分、机器学习、SQL 和 Python 编程。由于新冠肺炎·疫情，我参加的旧金山项目从现场转移到了远程。说这次经历充满挑战是一种保守的说法。根据我的经验，以下是我在参加数据科学训练营之前会做的 7 件事:
1.让你的生活井然有序
周一到周五，我在训练营的一天从早上 8:30 开始，到晚上 8:30 结束。然后我会每天再花 3 个小时学习当天教授的概念。我通常会在午夜睡觉。白天超级长。所以，在你开始训练营之前，确保你把所有的事情都准备好了。安排好托儿设施和你的个人管理问题。确保你也让朋友和家人知道你在训练营期间真的不在。
2.做好准备工作
你的训练营工作人员会在你开始计划前分配你要做的准备工作。这通常不是强制性的，但强烈建议这样做。你需要做这些准备工作。当训练营开始时，信息会很快向你涌来。你没有时间复习基础知识。你需要知道这些基础知识，这样你才能掌握更高层次的概念。例如，我们花了两天时间学习线性代数。然后我们被期望立即使用这些知识用 Numpy 构建向量和矩阵。因此，请务必做好准备工作。
3.买一台好电脑
你将训练复杂和资源饥渴的机器学习模型。你有一台好电脑是很重要的。Chromebook 不会满足你的课程作业。我建议买一台 Macbook Pro 或高性能个人电脑。
4.预精通 Python、Pandas 和 Git
在训练营的早期，你将需要在日常课程中使用这三种技术。
巨蟒
您将使用 Python 编写逻辑来构建您的模型。
熊猫
您将使用熊猫来争论和清理数据。
饭桶
您将在小组项目中使用 Git。
精通这些技术将会非常有益
5.买第二台屏幕或电脑
在训练模型、管理 Zoom、在 Slack 上聊天、在 StackOverflow 上研究之间，你的电脑会很快变得不堪重负。我强烈建议你再买一台电脑或屏幕来帮助管理这些任务。这会让你的生活轻松很多。
照片由 Mike Szczepanski 在 Unsplash 拍摄
6.了解数据科学中的 3 种不同角色
仅仅因为你参加了数据科学沉浸式学习，并不意味着你会或想成为一名数据科学家。对你想得到的工作类型有一个想法是很重要的，这样你就可以有效地选择你要建立的顶点项目的类型。以下是您完成该计划后可能有资格担任的主要角色:
数据科学家
数据科学家负责构建和评估机器学习模型。
数据工程师
数据工程师负责准备数据和建立数据管道。
数据分析师
数据分析师从数据中提取信息，为业务制定数据驱动的决策。
7.获取更多数据科学学习资源
你的训练营很可能会有很棒的教练。然而，有时这还不够。你可能需要更深入地学习某些科目，或者用不同的方式学习。我建议你找一些其他的资源来帮助你。我建议如下:
团队树屋
Teamtreehouse.com 以非常简单的方式教授编程概念。我发现这很有帮助。
数据营
DataCamp.com 专注于教授复杂的数据科学概念。这个项目通常比训练营的讲座更深入。
FreeCodeCamp.org
FreeCodeCamp.org 是一个免费资源，有详细的机器学习和编程教程。它也有一个很大的支持社区。
最后
数据科学训练营将是你人生中最艰难的挑战之一。重要的是你要尽你所能充分利用你的经历。我祝你好运。
业内成功数据科学项目的 7 个技巧
办公时间
你参加的任何课程都没有给出的建议
Racool_studio 在 freepik 上拍摄的照片
简介
我决定写这篇文章，因为它包含了课程中通常不会涉及的主题，或者任何其他与数据科学相关的材料。大多数资料包括你应该学习的工具、你应该知道的算法解释、数据科学项目的生命周期等等。
这篇文章不一样。它包括了我根据自己的经验收集的一些技巧，这些技巧相当普遍。不管你在哪个领域工作，它都是相关的。也许这与那些在创业环境中工作的人更有关系，但不是唯一的关系。而且，坦白地说，我把这篇文章看作是自己不时回顾的参考，以确保我在正确的轨道上:)
业内认为什么是成功的项目？
简单来说，如果你的项目给你的公司带来了价值，那就是成功的！但是，除了您的解决方案的准确性(或使用的任何其他指标)，一个关键因素是定制解决方案的速度。DS 项目通常需要时间，但理想情况下，我们希望它们越短越好。有些情况下，项目进行到一半时发现了一个错误，迫使我们(几乎)重新开始。这是我们想要避免的情况。这些技巧的目的是创建更好的解决方案，并在尽可能短的时间内集成它们。
那么如何才能让我们给公司带来的价值最大化？
1。定义问题和目标
经理:“我需要你建立一个模型，识别系统中流动的坏数据。”
我:“嗯，当然，没问题。只要让我知道数据在哪个数据库中，我就能马上找到它。”
但究竟什么是“坏数据”？为什么我们要过滤掉呢？这个项目的商业价值是什么？重要的是要明确问题是什么，我们的目标是什么。在这种情况下，假阳性的代价是什么？是否等同于假阴性？询问所有需要的问题，以便达到一个明确的目标，并且为您的项目创建一个明确的指标，最好是一个单一的值。如果你执行了构建模型的整个周期，却发现你没有完全理解问题到底是什么，这是一种耻辱。你可能不会完全回到起点，但这是在错误的方向上花费了很多努力。
有些情况下，你需要依赖公司的其他人员来完全理解项目。不要拖延，向前迈进，明确定义你的项目需要什么。
由于我们正在讨论项目的开始，我将添加另一个与项目的这个阶段相关的注释。你的经理不一定理解手头问题的难度。反映项目的初步结果(你将达到什么样的准确度，等等)是很重要的。).你可能会有点偏离，但是当你带着结果回来时，你不希望得到“哦…”的反应。从一开始就保持一致。
2。充分理解数据
经理:“标签列中缺少值。这表明注释者没有在图像中找到任何东西。
这听起来合乎逻辑。但是结果表明，缺少的值也表明注释者无法确定 6 个可能的标签中哪一个是最准确的，所以他将其留空。这两种情况是完全不同的，但是如果两种类型的缺失值被相同地对待，这将损害您的训练模型。
确保你很好地理解你的数据是至关重要的。您可能设计了一些功能，但后来发现设计错误(例如，您获取了一个“邮政编码”列并将其存储到某个国家的不同地区，但结果发现并非所有的邮政编码都属于同一个特定国家)。
无论是标签列，还是您将用作功能的列，确保您对数据的理解与您希望的模型一样准确。您甚至可以咨询注释者自己或他们的经理。不惜一切代价。
3。生产中会是什么情况？
经理:“相关数据在表一、表二、表三、表四。一个简单的连接就能得到所有的数据。”
太好了，你需要的都有了。您继续开发您的模型，获得了很好的结果，并且您已经准备好将它部署到生产中了。你只需要做最后的调整。
我:“说，哪一个来源提供字段 A？”
经理:“A 场？一旦数据完成了系统中的全部流程，我们就会对其进行一些充实。”
哎呀，这可不好。事实证明，这甚至是一个不会给模型的准确性增加太多的功能。但是你的模型已经用它训练过了。确保您了解您的模型将投入生产时的情况，这样您的模型将拥有所需的所有数据，并且适合生产中的特定设置。
4。保持简单
我:“我想我会先试试超级酷的型号。你怎么看？”
经理:“你是有知识的人。去吧！”
如前所述，通常你的目标是相对快速地带来结果。你的经理并不总是知道可能的解决方案是什么。通常，考虑到投入的时间，简单的解决方案更有价值。而且，不管投入多少时间，它们的表现往往比你认为很酷的超级复杂的解决方案还要好。当然，情况并不总是这样，但至少在转向“酷”的解决方案之前，先尝试更“简单”的解决方案。
此外，通常有可能用一个简单的解决方案至少部分地解决问题。这样做的时候，你已经在创造价值了。一旦完成，如果还需要的话，你就可以前进到更复杂的解决方案。
5。咨询他人
我:“是啊，我试过算法 a，这里看起来是个不错的解决方案。”
同事:“有意思，在这里可能行得通。不过我想我会在这里尝试算法 B。”
我:“嗯……没有想到。好主意！”
希望你不是公司里唯一的数据科学家。如果是这样，这是一个向他人学习的好机会，听听他们会如何解决你的问题。不要觉得不舒服。没有人能想出所有可能的解决方案，也没有人什么都知道。此外，通常情况下，一起头脑风暴的结果是，你自己会想到一个想法，如果没有这个咨询，你是不会想到的。
关于这个话题，我还想补充一下规划你的项目和将工作分成任务的重要性。集体讨论的结果应该就是这样。这将使你能够保持专注，而不是过多地研究一个潜在解决方案的特定算法。
6。误差分析
经理:“我想知道为什么模型在情景 A 和 B 中表现良好，而在情景 c 中表现不佳。”
我:“我觉得另一个算法会更好。此外，对更多数据的训练可能会奏效。”
是啊，这可能不是你得到这份工作时的梦想。但这非常重要。手动查看几个(或许多)错误可以给你一个很好的直觉，知道哪里错了。不要觉得这“不是我应该做的事情”。这可能比仅仅向你的模型扔更多的数据更有效。
7。文件
我:“我从数据中过滤掉那些行是有原因的。我不记得我为什么那样做了……”
这有时是一个被忽视的步骤，或者只是做了一部分。你正在做的当前项目中有一些元素，当你下个月继续下一个项目时，你会忘记它们。记录您在整个项目中采取了哪些步骤，选择了哪些数据及其原因，您在 DB 上运行的查询(当然还有您的代码！).越多越好。当您可能需要修改项目并改进您的解决方案时，或者当您将要处理与此项目相关的另一个项目时，这将非常有用。你甚至可以在仍然进行项目的时候从文档中获益(“为什么我又决定走路线 A 而不是路线 B..?").
结论
如果我不得不用几句话来总结一个人为了在行业中部署一个成功的项目需要做什么，我会说务实和与你的同事和经理良好沟通很重要。不要被动，要主动，确保你拥有所有你需要的信息。并且把你的注意力集中在你的目标上。我希望你觉得这很有见地:)祝你好运！
制作优秀 CMake 脚本的 7 个技巧
如何让你的 DevOps 生活更轻松
Photo by 贝莉儿 DANIST on Unsplash
CMake 已经成为 c++构建自动化、测试和打包的事实上的标准工具。它广泛用于多平台开发，并支持为大多数 C++编译器生成构建文件。自从 21 年前推出以来，它走过了漫长的道路，增加了对许多优秀特性的支持，在 C++开发人员中广受欢迎。
在这篇文章中，我想向你介绍一些可能帮助你编写更好的 CMake 脚本的技巧。虽然您可能已经熟悉其中一些，但我相信您也会发现一些有用的。
1.始终使用 target_*()命令
由于向后兼容，像 add_definitions 、include _ directory、 link_libraries、等函数在现代 CMake 中仍然存在。但是，只要有可能，您应该更喜欢使用它们的对应项target _ compile _ definitions、target _ include _ directory、 target_sources、或 target_link_libraries 来代替。
由于不带 target_ 的函数没有指定作用域，它们将泄漏到目录中指定的所有目标。例如，如果您想要构建一个可执行目标，它还依赖于子目录中定义的库，您可以这样指定它:
project(main_project)
add_executable(main_project main.cpp)
add_subdirectory(dependency_lib)
include_directories(include_files)
不幸的是，由于 include _ directories 中指定的目录被附加到当前 CMakeLists.txt 文件中所有目标的列表中，它们也将被附加到 dependency_lib 。因此，我们最终可能会在 dependency_lib 中使用错误的包含文件。这同样适用于其他命令。尤其是使用 add_definitions 或者 add_compile_options 这样的命令，这可能会导致一些难以发现的编译错误。
另一方面，使用target _ include _ directory或 target_link_libraries ，我们显式地指定了我们想要使用的目标，避免了任何泄漏问题。此外，这些命令让我们可以有选择地指定实现所需继承行为的范围(见下一篇技巧)。
2.使用目标传递来指定依赖关系层次结构
在现代 CMake 中，目标命令让您使用接口、私有和公共关键字来指定命令范围。如果您想要将依赖从子目标延续到父目标，这是很有用的。
例如，让我们考虑下面的代码:
project(main_project)
add_executable(main_project main.cpp)
add_subdirectory(dependency_lib)
target_link_libraries(main_project PRIVATE dependency_lib)
在子目录 dependency_lib 中，我们有以下 CMakeLists.txt:
project(dependency_lib)
add_library(dependency_lib SHARED library.cpp)
add_subdirectory(sub_dependency_lib)
target_link_libraries(dependency_lib PRIVATE sub_dependency_lib)
显然，我们有一个依赖关系的层次结构。 main_project 依赖于 dependency_lib ，后者又依赖于 sub_dependency_lib 。这样写， sub_dependency_lib 对 main_project 是不可见的。这意味着 main_project 将不能直接使用 sub_dependency_lib 的任何函数。如果你将关键字 PRIVATE 替换为 PUBLIC，你也可以在 main_project 中使用 sub_dependency_lib 。如果 dependency_lib 没有完全隐藏依赖关系，这是很有用的，这是经常发生的情况。INTERFACE 关键字使用频率较低，它指定一个在“上游”目标中使用的依赖项，而不在声明它的目标中使用(在本例中， sub_dependency_lib 对 main_project 可见，但不会在 dependency_lib 本身中使用)。
3.防止源代码内生成
在配置任何 CMake 构建之前，您应该执行的默认步骤是创建一个构建子目录，然后运行 CMake。但是，有时您可能会忘记创建附加目录并在根目录下运行 CMake。这种“源代码内构建”污染了您的项目，并在 git 中产生了许多变化。
如果您想要禁用源代码内编译，请将下面几行放到您的根文件 CMakeLists.txt 中:
if(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_BINARY_DIR})
message(FATAL_ERROR “In-source build detected!”)
endif()
这个简单的脚本比较了源目录和构建目录，如果它们相等，就会抛出一个错误。
4.指定跨平台 C++一致性的语言标准
建议使用以下定义为每个 CMake 项目指定 C++标准:
project(main_project LANGUAGES CXX)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)
这确保了在给定编译器支持的情况下，标准将被强制执行，并关闭非标准 C++特性。避免通过添加编译标志来设置 C++标准。这不是跨平台兼容的，因为每个编译器使用不同的标志。
如果需要更好的控制，可以指定编译器支持的具体 C++特性:
target_compile_features(dependency_lib
PUBLIC
cxx_nullptr
PRIVATE
cxx_variadic_templates
cxx_lambdas
)
在这种情况下，我们要求 dependency_lib 编译时支持变量模板、nullptr 和 lambdas，而上游目标也应该编译时支持 nullptr。
5.如果您的项目包含 CUDA 代码，请将 CUDA 添加为一种语言
有了 modern CMake，您就不仅仅局限于 C 或 C++。CMake 还支持其他语言，如 Objective-C 或 Fortran。C++世界中使用频率较高的语言之一是 CUDA，NVIDIA 的 GPGPU 编程语言。设置 CUDA 传统上是相当困难的。使用 CMake，您可以将 CUDA 作为编程语言添加到 CMake 项目中，如下所示:
cmake_minimum_required(VERSION 3.8 FATAL_ERROR)
project(cmake_and_cuda LANGUAGES CXX CUDA)
然后，您可以像添加 C++源文件一样轻松地添加新的 CUDA 内核:
add_executable(cmake_and_cuda kernel.cu kernel.h)
要选择特定的 CUDA 架构，您可以将以下内容添加到 cmake 命令中:
cmake -DCMAKE_CUDA_FLAGS=”-arch=sm_75” .
6.将重复的 CMake 代码放在宏或函数中
与任何其他编程语言一样，CMake 也提倡不重复自己(DRY)原则。将需要两次以上的代码放在单独的函数或宏中总是好的。CMake 中的宏定义如下:
macro(foo arg)
<commands>
endmacro()
另一方面，函数被定义为:
function(foo arg)
<commands>
endfunction()
尽管这两个概念非常相似，但它们在作用域上有所不同:一个函数定义了它自己的作用域，而一个宏的行为就像你在使用它的地方粘贴了代码一样。例如，宏中的 return()语句不是从宏返回控制，而是返回封闭范围的控制。
7.使用 ExternalProject 添加自定义目标
如果您的项目依赖于自定义目标，例如外部存储库，您可以使用 ExternalProject 模块。 ExternalProject_Add 命令允许您下载并使用 git repo，如下所示:
ExternalProject_Add(
Eigen
GIT_REPOSITORY "https://gitlab.com/libeigen/eigen.git"
GIT_TAG "${EXPECTED_EIGEN_VERSION}"
SOURCE_DIR eigen
BINARY_DIR eigen-build
CMAKE_ARGS
-DBUILD_TESTING:BOOL=OFF
-DBUILD_SHARED_LIBS:BOOL=ON
)
在这个例子中，我们使用了流行的 Eigen3 矩阵向量库，方法是指定存储库 URL、要检查的特定 git 标记、源目录和普通 CMake 项目中的二进制目录，以及 CMake 参数。除了 git，该命令还支持 Subversion、CVS、Mercurial 和普通下载。默认情况下，添加的项目被假定为 CMake 项目(尽管并不需要如此)。您也可以指定单独的 CMake 生成器和单独的构建命令。
指定外部项目后，它可以用作另一个 CMake 目标，即您的目标可以依赖于它，外部项目本身也可以依赖于其他目标。你可以在 CMake 文档中找到更多关于 ExternalProject 模块的信息。
结论
现代 CMake 是一个用于定义整个软件构建的广泛且可扩展的系统。它支持许多不同的平台和语言，并允许您建立一个相互依赖的目标层次结构。最后一个技巧:将 CMake 代码视为代码库的一部分，并好好维护它。这将使构建过程对项目的所有开发人员透明。
资源
- CMake 文档:【https://cmake.org/cmake/help/v3.20/
- CMake 目标说明:https://lei Mao . github . io/blog/CMake-Public-Private-Interface/
- 目标及物性解释:https://pspdfkit.com/blog/2018/modern-cmake-tips/
我希望在清除所有 HackerRank Python 挑战之前知道的 7 个技巧
这将提高你的编码速度和效率
当你编码时，要像水一样。—作者照片
我最近发表了一篇关于我如何在两周内清除所有黑客排名 SQL 挑战的文章。这是一次有趣的旅程，没有理由不乘势而上，重温我的 Python 技能。所以，三个星期后，我在这里写这篇文章，与你分享我的经历和我从旅程中学到的技巧。这篇文章中没有代码，所以即使你对 Python 或 Hackerrank 一无所知也不用担心。本文将分享我希望在开始 Hackerrank 挑战之前知道的七个技巧。这篇文章是关于 Python 挑战的，但是它也将推广到其他语言和其他有竞争力的编程平台。我希望你能学到一些东西。让我们直接跳进来吧！
小贴士#1:从简单开始，慢慢向上
L 像大多数其他竞争性编程平台一样， HackerRank 将挑战分成不同的难度等级。当你第一次开始的时候，最好的方法是使用右边的过滤器，从简单的开始，然后逐步降低难度。
作者照片
有三个难度级别:
- 简单 —这些是基本的语法掌握和最佳实践问题。它帮助你热身和更新你的语言知识，让你为更复杂的挑战做好准备。如果你很了解这门语言，你会很快掌握它，所以先把它弄清楚不会浪费你太多时间。如果你发现一些简单的问题实际上很难解决，那么是时候回到你的基础语言训练场温习一下了。否则，你以后会发现一些不可能解决的'中等的或'困难的'挑战。
- 中等 —这些挑战通常需要你把多个棋子放在一起才能解决。也许字符串操作加上列表理解，或者正则表达式加上集合数据结构，等等。完成这些问题后，你将能够挑选合适的数据结构/类并让它们一起工作来解决问题。
- 硬的——数量不多，但都是真肉。它要求你把所有的东西放在一起，在时间/空间限制内找到最优的解决方案。某些问题需要特定的算法来解决，但算法不是 Python 特有问题的重点。这些挑战是为了帮助你提高 Python 技能，而不是数据结构和算法技能。所以它们不会太难解决。不过，大多数“困难”问题，你无法用蛮力解决。
所以最好的策略是从简单的开始，掌握编程语言的所有部分。然后练习你把多个一起来解决'中题的能力。一旦你觉得这样做很舒服，试着去解决那些困难的问题。这样，学习曲线就不会太陡，你更有可能成功而不会受挫或被卡住。
技巧 2:记录，重新应用，重复
由 Roman Synkevych 在 Unsplash 上拍摄的照片
我称之为 RRR 方法。记录，重新应用和重复。让我解释一下这是什么意思。
记录
如果你在做特定语言的挑战，而不是算法或数据结构的问题，那么可以很有把握地假设，在某种程度上，你还在学习诀窍。如果这就是你，那么记录下你一路上的成功和失败会让你受益匪浅。挑战的目的仍然是学习，它包括记笔记，反思你做的对或错，分析问题，找出模式等等。试着问自己一些有质量的问题，比如:
- 什么问题在考验你？
- 使用了什么技术/数据结构/语法？
- 你的解决方案是最佳的吗？有替代方法吗？这些与您的解决方案相比如何？
- 在
Discussion部分，投票最多的解决方案是什么？为什么这样您能否将他们的一些技术整合到您的解决方案中并使其更好？
记录下你在解决问题时学到的新技巧/片段，将会在解决问题的过程中建立一个片段库，你可以在以后参考。建立一个片段库可以为你节省更多的时间来完成后面的挑战，并且对间隔重复也很有帮助。如果你是有条理的类型，你可以给你的代码片段分配问题类型/模式标签，这样在将来，你可以很快回去抓住它，以促进你的问题解决过程。你可以在这里找到我的笔记！这就像一个围棋手。这里的一点点记忆会有很大帮助。
更好的是，你可以在 Github Gist、Twitter 甚至 LinkedIn 上分享你的代码，在帮助他人的同时展示你的进步。有多重好处。公开你的记录迫使你更清晰地思考，更多地重构你的代码，并且在应对挑战时总体上更清晰地思考。有一篇关于在公共场合学习的好处的优秀文章，你可能想看看。
重新申请
一旦你记录了你刚刚学到的东西，在做新的挑战时，尽可能地重新运用它们。努力把你学到的东西变成你的第二天性。当你在相对较短的时间内顺利通过所有挑战时，这一点尤其容易实现。你通过练习你所学的，加深你的理解，并使用那些新颖的/外国的技术和想法，比如呼吸，来完成这个循环。
重复
重复步骤 1 和 2。你会发现自己在实践中学习新的东西，发现更多的模式，并将最佳解决方案添加到你的代码库中。
太阳升起又落下，你经历了一个又一个挑战，键盘敲击声，脸上的假笑，心如止水。这是成长，我的朋友。这就是成长的样子。
技巧 3:阅读讨论，但不要太沉迷于一句话
在 Hackerrank 中，讨论区可能是我学习最多的地方。在这里，您可以检查其他人的解决方案以及他们的基本原理。Hackerrank 的社区友好、开放且乐于助人。人们通常会用代码片段和优秀资源的链接来回答他们为什么以这种方式应对特定挑战的问题。所以不要忽视讨论，即使你已经战胜了挑战！
我通常的做法是尝试自己解决问题，不管有没有蛮力。这有助于我更深入地理解这个问题。然后去讨论区看看其他人的解决方案。我试图在不偷看他们解释的情况下理解解决方案。如果我卡住了，我会然后检查解释。我不知道有多少次我被其他人想出的聪明、漂亮和优雅的解决方案惊呆了。我通常会记笔记，并尝试在未来的挑战中运用这些笔记。
不过，有一个问题。社区倾向于支持那些“性感”的俏皮话，即使它们很难读懂。您可能也想在您的解决方案中这样做。它让你感觉很好。不要太执着！在现实世界中，可读性仍然胜过一行程序。走向另一个极端，总是试图做一行程序实际上会伤害你的编码风格。
技巧 4:卡住时，达到峰值！
投票率最高的解决方案——作者照片
D 正在进行的编码挑战，你将不可避免地遇到你的停滞时刻。无论你花多少时间，用多少不同的方法来解决问题，你还是找不到出路。这就是“15 分钟”规则发挥作用的地方:
用 15 分钟的时间，尽你所能解决问题。但是，如果 15 分钟后还没有答案，你 一定要 找人问问。”
事实是，在大多数情况下，在一个问题上停留超过 15 分钟是不值得的。并非所有的挑战都是平等的。一些挑战没有很好地设计或阐述(这尤其是 Hackerrank 抱怨最多的问题)。所以不要让他们担心。去讨论区看看其他人的解决方案。有时候你会发现别人抱怨问题的模糊性，你会感谢我没有在一个愚蠢的问题上浪费你 1 个小时的宝贵时间。😏
把你的时间用在更重要的挑战上是对时间的更好利用。
技巧 5:你不必使用提供的代码
为挑战提供代码—作者提供照片
有些挑战会给你很多预先写好的样板代码，只留下一个功能让你填写。这通常是有帮助的。您可以专注于要解决的问题，而不是“逻辑代码”。然而有时，我发现提供的代码限制了我的思考。一些提供的代码将为您导入某些库，如果您使用它们，您将使用它们解决问题。然而，最佳解决方案可能根本不使用库。这个问题可以用多种方法解决，而您只限于使用提供的库。所以我的建议是，嗯，如果你有更好的想法，你不必遵循提供的代码。例如，时间增量挑战给了你 re、os、math、random、sys，然而你并不需要使用其中的任何一个。最好的方法就是使用DateTime库或者calendar库。
自由思考，跳出框框思考。
提示 6:使用你的黑客工具，不要吝啬
Hackerrank Hackos 交易——作者照片
这是一种虚拟货币奖励，奖励解决挑战的人，在 Hackerrank 中称为 Hackos 。然而，你可以使用它们的地方并不多。最大的用途是解开测试用例的挑战。挑战用这些测试案例来判断你是否通过。有时，您的解决方案在部分测试用例上工作，但不是全部，您可以解锁那些失败的测试用例，并更好地调试您的代码。我的建议是:不要吝啬你的 Hackos。反正 Hackos 在其他地方也没什么用处，所以完全用它来解开那些测试用例，加速你的成长。找出你在哪里跌倒，并解决这个该死的问题。
技巧 7:启用 Vim 或 Emacs 模式
这是给你的vim或emacs爱好者的。如果你碰巧是一个，这样做肯定会改善你的编码体验，如果不是你的编码效率。Hackerrank 的代码编辑器支持vim或emacs快捷键。因此，如果你用这两个程序编码更快，你应该完全打开开关。
Hackerrank 编码编辑器支持 vim/emacs 模式—按作者拍照
奖励:如果你通过了挑战，就参加测试。这将是一件轻而易举的事！
Hackerrank 证书—作者照片
ackerrank 提供多种语言和不同水平的认证。对于 Python，他们只提供了'的基础级别。所以，如果你碰巧已经通过了所有的挑战，那就千万不要参加认证考试。这将是一件轻而易举的事，谁不喜欢自己的个人资料上有一个闪亮的徽章让潜在的招聘人员看到呢？
结论
我花了三周时间清除了 Hackerrank 上的所有 Python 挑战。(比 SQL 挑战稍长一点，我有另一篇文章讨论我的 SQL takes，如果感兴趣的话你可以看看。)对我来说最大的收获是:
当你失败的时候，正是你成长的时候。
我学到最多的挑战是那些花费我最长时间的挑战。即使应用了 15 分钟规则，我仍然很难理解别人的解决方案，并把它们应用到我自己的解决方案中，等等。我想那是因为我找到了自己知识的薄弱点？
当你失败的时候，那就是你真正成长的机会出现的时候。拥抱它，珍惜它，抓住它，不要害怕它。让它成为你未来成功的垫脚石。几乎所有成功人士都走这条路。快速高效地失败 99 次，然后获得你应得的最终大成功。
我希望你觉得这篇文章读起来很有趣，并从中学习到一些东西。如果你想更多地了解我对数据科学的思考、实践和写作，可以考虑报名成为 Medium 会员。每月 5 美元，你可以无限制地阅读媒体上的故事。如果你注册使用我的链接，我会赚一小笔佣金。
https://lymenlee.medium.com/membership
如何启动你的自由数据科学事业的 7 个技巧
Vladimir Solomyani 在 Unsplash 上的照片
意见
我是如何在不到一年的时间里从每小时 50 美元涨到 150 美元的
无论你是在寻找新的职业还是只想赚点外快，如果你知道自己在做什么，数据科学自由职业会非常有利可图。不幸的是，大多数有抱负的自由职业者都没有成功。以下是一些对我在这个领域的成功至关重要的提示，我希望它们也适用于你。
1.不要被物流问题所困扰
最初，我被我“需要”做的事情淹没了。找到一个没被取过的朗朗上口的名字，建一个网站，设计一个 logo，领一个营业执照，这样的事情不胜枚举。我最终决定直接跳进去。就我个人而言，我不喜欢我的企业名称或标志，我的网站仍然没有完成。有一天我会解决这些事情，也许， ，如果我的工作慢下来 。
老实说，我从这些事情中很少看到回报。客户很少点击这个链接。他们真正寻找的是一份可靠的建议书和良好记录的证明(两者都将在下面讨论)。
2.选择一个平台
当你刚刚起步的时候，不要浪费时间自己去找客户。我花了几周时间给企业打电话，申请顾问职位，联系我的人脉，但收效甚微。我发现使用自由职业平台更成功。简单的谷歌搜索就会显示有很多。我个人用 Upwork。大多数人会从你的收入中抽取一定比例。值得！记住，你的核心竞争力是数据科学，而不是销售。利率可能在 5-20%之间，通常会随着你投入更多的时间而下降。这可能让人觉得很多，但对于用传统方式寻找客户所节省的时间来说，这是一个很小的代价。顺便说一句，我保证他们不会付钱让我写这个，这真的对我有用。
3.创建一个可靠的提案模板
有一个可靠的提案是很重要的。根据具体项目进行修改。有很多教程可以帮助你做到这一点。我个人喜欢在谈论过我参与过的类似项目以及我在这些项目中取得的成功后，轻松地强调我的经历。有时候我会分享一些类似项目的好评。如果我有一个以前的项目，我可以分享，甚至更好。尝试看看什么对你有用。
记住，这不是一份简历。客户唯一关心的是你能否以合理的价格完成这项工作。如果你能证明这一点，不管你上过什么学校，他们都会选择你而不是其他人。
确保按照你的价值出售它们。当我第一次开始时，我确保在我的提议中包含一些关于以较大折扣工作的内容，因为我是这个平台的新手，但有很长一段成功项目的历史。现在，我将典型地指出，由于我的经验和编码效率，我以较低的总成本生产更精确的模型。客户喜欢知道他们以优惠的价格买到了高质量的产品。
4.找到你的第一个客户
获得第一个客户是最难的。我花了几周时间和数百份提案。我保证会变得更容易！一旦我有了第一个 5 星评价，第二个客户花了一半的时间。第三次花的时间是第二次的一半。一晃一年过去了，现在我都没看一眼就有客户来找我了。实际上，我收到的工作请求比我有时间处理的还要多。
你的前几个客户是为了建立评论，而不是赚钱。我开始时每小时只收 50 美元。与 Upwork，你会得到一个“新星”徽章后，几个成功的项目。这很有帮助，因为许多客户专门寻找这些讨价还价的自由职业者。
偶尔你会发现一个客户给你所有的招聘信息。有三次，我解决了他们的问题，没有先被录用就把解决方案发给了他们。如果你走这条路，动作要快！许多客户会立即选择第一个合格的自由职业者。这无疑是一个风险，但我获得了其中两个项目的合同，这在提升我的形象方面创造了奇迹。
最后，如果一个客户与你合作，但决定和其他人合作，不要害怕寻求反馈。我收到了很多有用的建议和批评，从长远来看，它们帮助了我。
5.有机增长你的利率
在你最初几个成功的项目之后，开始逐步提高你的速度。如果你找不到工作，再把它拿下来。使用 Upwork 的高级版本，您可以看到一个项目的投标范围。看到这些信息每一分钱都是值得的，因为你可以看到什么时候你可能会比正常情况下更高，或者你是否会冒着失去合同的风险(或者甚至不应该为此费心)。
对我来说，真正的关键是个人资料率。一旦我有足够多的工作要做，而没有足够的时间去做其他项目，我就会提高我的档案率来减缓请求的速度。把它想成一个“考虑到我现在工作的时间比我想的要长，他们会给我多少钱？”令我惊讶的是，这并没有让事情慢下来。然后我把工资提高了，因为我真的没有足够的时间承担更多的工作。又一次，工作源源而来…在过度劳累了大约一个月之后，我能够确定我的平衡速度；工作持续以我感到舒适的节奏进行的速度。如果我决定全职做这项工作，我可能会降低费率以获得更多的合同。这都是一种平衡行为。
最后一点:自由职业者的工作并不总是(永远？)稳。我认为这是因为许多公司都有类似的年度预算周期。有几个月，我过去的所有客户都在同一个星期来找我，也有几个月，我对此不感兴趣。因为我的项目通常持续几个月，所以它对我的影响并不大，但当你调整利率时，这是需要注意的。
6.找到(拥抱)你的位置
我刚入门的时候，想做的都是 AI。问题是，每个数据科学家都想要这些工作。因此，我最初的几份工作是在我比其他自由职业者更擅长的传统技能领域:高级 Excel VBA 建模和预测。从那里，我能够扩展到 Python ML 模型，它将干净地集成到客户的 Excel 工具中。现在，我可以找到一份纯人工智能(非 Excel)的工作，但他们的工资没有 Excel 的高。为什么？因为大家都想做 AI，但是能把 AI 集成到 Excel 里的很少。我更喜欢完全在 Python 中工作吗？是啊！足以降低我的利率？那鸿
现在我不是说你要掌握 Excel，做我在做的事情。请不要！如果每个读到这篇文章的人都决定排挤我，我会很不高兴。我说的是你应该找一些你能做的独特的事情。例如，Tableau 增加了与 Python 集成的能力。如果你是画面专家，接受它。也许你是像 Matlab 这种现在很少用的工具的专家。你拥有的任何奇怪的、遗留的、甚至过时的技能都会有客户迫切需要你的帮助。如果你能把那些没有设计在一起的技术结合起来，那就更好了！一旦你获得了他们的信任，就转向你真正想做的项目。看看外面的提议，了解一下客户在寻找什么。如果你真的想做得好，不要像我刚开始做的那样与你的利基市场斗争，拥抱它。
7.勇往直前，去征服！
自由职业对我来说非常有益，不仅仅是在金钱方面。我现在从机会成本的角度看待这个世界。我真的想今晚狂看另一场网飞秀，或者为我想去的旅行多挣 300 美元吗？有时候我确实会大吃大喝，但是我发现我现在很少这样做了，因为我终于明白了我的时间的价值。不仅仅是自由职业者；我现在花更多的时间和家人在一起，或者学习新技能。对我来说，自由职业创造了一个范式的转变，让我成为一个更快乐、更有效率的人。
你还在等什么？别再看这个了，去跳台吧！(除非你想先连接或鼓掌)。如果你需要灵感，以下是我的个人资料:https://www.upwork.com/freelancers/michaelmalin
关于我
我是一名拥有 10 多年经验的数据科学自由职业者。我一直希望与人交流，所以请随意:
如有任何问题请在下方随意评论
赢得数据科学博士面试的 7 个技巧
办公时间
如何通过博士申请面试，获得梦想中的博士职位。
每年的这个时候，准博士生都在为下一学年开始的博士职位进行面试。在过去的一周里，我面试了大约 40 名潜在的学生。每年申请人的素质似乎越来越好。我一直对学生们所做的很酷的事情感到惊讶，不仅仅是作为他们学位的一部分，也是超越学位的一部分。也就是说，不要让高标准影响你。如果你被邀请去面试，那么你也是这些学生中的一员！
这里有一些让你在博士申请面试中胜出的小技巧。我的重点是数据科学领域的博士面试，尽管这些技巧中有许多是普遍适用的。
- 你的动力是什么？如果你还没有问过自己这个问题，博士选拔小组肯定会问的！博士学位是一个漫长的过程，所以你需要有正确的理由去读它。我相信你已经考虑过这个问题了，但是你不仅要考虑为什么你想读博士，还要考虑为什么你申请的这个博士项目适合你。上周，我看到一些学生的眼睛真的亮了起来，他们解释了为什么我们面试的特定博士课程最适合他们，自然地列出了该课程的所有方面以及它与他们的兴趣的关系(他们简历中显示的相关过往经历进一步证实了这一点)。
- 准备好你申请的博士项目。如果你能和现在的博士生交谈，那很好，但是你真正需要做的是阅读网站或相关的说明书。你会惊讶于有多少学生没有这样做。虽然这些背景信息将非常有助于你选择合适的博士课程，但它也将确保你能够证明你了解你将进入的领域，并且你已经考虑过为什么这样的课程非常适合你。虽然知道这个项目不会为你赢得一份工作，但是不知道你申请的是什么肯定会让你失去一份工作。如果你申请的是一个特定的研究项目，那就研究一下。不需要成为这个领域的专家——毕竟，这就是博士学位的目的——但是做一些关于这个项目的背景阅读，这样你就可以展示你的兴趣。
- 讲一个好的(相关的)故事
如果你在面试数据科学博士，那么你有可能会被问到你过去做过的一个项目。这通常可以是任何项目:硕士、本科生、暑期、实习、爱好项目或任何真正的项目。所以，想好一个项目，最能展示你的专业知识，最适合你申请的博士项目。事先想想项目的哪些部分真正展示了你认为可能对博士有用的技能。至少小组中的一些成员不会熟悉你项目的背景，所以设定背景，提供一个温和但简短的背景。事先和朋友讨论你的项目会有所帮助。 - 紧扣主题，言简意赅
面试小组有很多面试要完成。他们想在很短的时间内从你那里得到尽可能多的信息。尽可能彻底地回答他们的问题，但不要含糊其辞。把你的要点讲清楚，然后继续下一个问题。 - 真实地告诉我们你的希望、梦想、抱负和恐惧。别告诉我们你认为我们想听的。如果你做了一些事情，比如一项工作或一个项目结果不太好，说出来。告诉我们为什么。告诉我们你学到了什么。告诉我们下次你会有什么不同的做法。如果事实并非如此，不要为为什么这是最好的事情找借口。上周，我们问了一名学生一个不寻常的职业选择，从表面上看，这个选择没有多大意义。这名学生解释说，他们认为他们不寻常的职业变动可能会帮助他们实现一个长期的梦想…成为一名宇航员！不用说，面试小组对此印象深刻。
- 我们希望你表现出色面试小组希望你表现出色。如果你说了一些似乎不合理的话，他们可能会找你麻烦，但一般来说，他们不会试图让你犯错。他们想确保对你的背景和专业知识有一个完整的了解。他们通常会问你一些引导性的问题，让你有机会详细阐述你简历或其他证明文件中的观点。抓住机会，抓住它。
- 你不是冒名顶替者
面试可能是一次令人伤脑筋的经历，但其实不必如此。面试小组只是想对你有所了解，了解你的背景、技能和兴趣，看看你是否适合这个项目。冒名顶替综合症非常普遍，一些学生在面试前确实会非常紧张。但是请记住，如果你不值得参加面试，你就不会被邀请参加面试。所以放轻松，试着和一些想更好地了解你的人进行简单的聊天。
祝你好运！
破解数据科学和机器学习面试的 7 个技巧！
帮助你在数据科学和机器学习面试中表现更好的 7 个详细技巧
照片由 Maranda Vandergriff 在 Unsplash 上拍摄
毫无疑问，生活给予的最好奖赏
是努力做值得做的工作的机会。——西奥多·罗斯福
如果你不知道在面试过程中你到底需要什么，准备与数据科学和机器学习相关的面试有时会很难，很痛苦。在数十亿个可能的问题中，你总是想知道你可能会被问到什么话题，或者面试官希望你具备什么知识。
参加了大约五家不同公司的面试，并成功破解了这些面试，这让我意识到一些在这些面试中取得成功的好的和相关的技巧，以及我随机应变的方法中的缺点。我很乐意与大家分享这一经验和技巧。
如果您试图准备数据科学的每一个方面，尤其是在有限的时间内，这对您来说可能是一项艰巨的任务。因此，你需要调整好自己的节奏，并做出相应的计划。
下面提供的文章是一个逐步详细的说明，将指导新的数据科学爱好者和爱好者在 12 个月内掌握成为数据科学专家所需的技能。在这段时间内，可以涵盖大多数主题和基本技能。
</12-steps-for-beginner-to-pro-in-data-science-in-12-months-c6f6ba01f96e>
在这篇文章中，我们的主要目标将集中在技术和实践两个方面，这两个方面对于个人成功通过数据科学或机器学习面试是必不可少的。我们将详细分析这七个技巧，以理解面试的最佳方法。虽然软技能，如有效的沟通，适当的着装和其他因素也是必不可少的，但这些都是更一般的术语，不会在本文中讨论。
假设您在解决与数据科学相关的问题方面有相当多的知识，并且对数据科学和机器学习中的所有基本主题有基本的了解，让我们继续深入研究您的文章。我们将分析破解数据科学和机器学习面试的七个最重要的技巧。
1.磨练你的基础知识
磨砺你的基础和初始技能是非常重要的。在开始实际的面试准备之前，有必要磨练你的基础知识，掌握你遇到的每一个基础数据科学主题。为了更具体地说明这些基本概念，让我们分别详细阐述其中的每一个方面。
在使用数据科学时，请注意一些基本概念，您需要分析这些概念来开始整个面试过程。数据概念、数据挖掘、数据可视化、特定库的关键概念，帮助您处理各种项目和问题。
在用数学为数据科学面试做准备时，通常在面试的早期阶段不会问太多数学术语或概念。然而，这个事实也取决于选择面试你的公司和他们的具体要求。线性代数、概率和统计、降维以及关于激活函数和优化器的概念的一些关键方面的坚实基础可以被触及。
转到编码方面，通常，大多数公司会允许你选择任何你能自如使用的特定编程语言。对于数据科学和机器学习，你最应该关注的语言是 Python 和 SQL。虽然 R 在解决许多与数据科学相关的任务方面有所实践，但我强烈建议首先提高您的 Python 和 SQL 技能。Python 是最简单且被广泛使用的语言，用于解决与数据科学和机器学习相关的各种复杂任务。另一方面，SQL 发现它的效用是构造大型数据库，这是解决数据科学中复杂任务的有用需求。
当开发一个代码块来解决一个特定的问题时，确保你解决这些问题的方法与这个特定的问题最相关和最合适是很重要的。在第一轮面试过程中，通常会有一轮编码面试。这篇文章是在这些采访中被问到的一个特殊问题的例子。看看下面的帖子，学习一些常见类型的模式编程的解决方案。
最后，我们将触及机器学习，这是大多数面试的一个重要方面。在机器学习中，尝试接触并涵盖机器学习算法的基本主题，如决策树、随机森林、K 近邻(KNN)、线性和逻辑回归、聚类算法和其他签名算法。确保接触到解决复杂的机器学习任务所需的最有用的 python 库。这些库包括 pandas、matplotlib、scikit-learn、TensorFlow 和其他重要的库。尝试专注于对实现机器学习任务和目标的直观理解和方法，以获得更高的成功率。
2.要自信
“当你非常自信，觉得没人能打败你时，对其他人来说，比赛就结束了。”
–简森·戴伊
Jordan Donaldson | @jordi.d 在 Unsplash 上的照片
自信是你选择的任何面试程序中不可或缺的一部分。那么，对数据科学面试有信心有什么特别之处呢？
尽管自信对于几乎任何面试都是一个基本因素，无论是否是数据科学，但不可否认的是，要想在数据科学面试中取得成功，你的自信必须达到前所未有的高度。数据科学领域的复杂性和纯粹的广阔性要求爱好者深入探索所有这些基本技能的细节。
你在数据科学领域执行的每一项任务都需要一定程度的自信。失败是数据科学最重要的方面之一。在处理大量问题时，你会遇到许多情况，你会感到茫然，不知道完成特定任务必须采取什么方法。同样，当你在面试中被问到一个问题时，即使你知道答案，你也可能会昏过去。在这种情况下，保持冷静和自信是很重要的。这将最终有助于破解这些复杂的采访。请点击下面的链接，查看我以前的一篇关于成功的数据科学家的五个最重要的品质的文章。
虽然自信很重要，但过度自信可能是个大问题。当你在面试准备前选择不回忆和重温数据科学的重要话题，并且你认为你什么都知道时，关键问题就出现了。或者你只是快速浏览一下所有的主题，没有太多的重点。这个因素可能对你的整个选择过程极为不利。因此，在面试过程中保持自信是很重要的，但也要确保你已经做好了充分的准备，并且你有合适的工具来征服面试过程，以达到最佳效果。
3.承认你的简历
Bram Naus 在 Unsplash 上拍摄的照片
数据科学是那些不强制要求你有学位的领域之一(尽管它对在一些公司获得面试有帮助)。数据科学最棒的地方在于，你可以用你的简历或作品集来说明你在学习这门学科期间所取得的成就。
数据科学最重要的方面之一是你在特定领域学习期间所做项目的质量。只要有机会，每个数据科学爱好者都必须继续从事大量的项目。除了获得项目的实践知识和理论理解之外，你还能够实现将这些技能项目添加到你的简历和文件夹的成就列表中的目标。
我强烈推荐查看下面提供的文章链接。该列表涵盖了 2021 年及以后的 15 个令人敬畏的 Python 和数据科学项目。对于大多数初学者和数据科学爱好者来说，本指南应该是有用的，可以让他们更深入地了解他们可以从事的各种项目，并添加到他们的简历中。我将文章分成了许多部分，涵盖了面向所有级别用户的简单、中级和高级项目。请随意查看，为你的简历和作品集添加更多令人惊叹的项目。
</15-awesome-python-and-data-science-projects-for-2021-and-beyond-64acf7930c20>
确保你在你选择加入简历的项目中进行了广泛的工作和研究。你应该对你在简历中展示的特定项目有最终和绝对的了解。不要仅仅为了给你的投资组合增加更多的元素而增加它们。你将会被详细询问这些话题，如果不能回答相关的问题，将会对你的选择过程不利。因此，明智一点，在你把这些项目加入简历之前，全心全意地去做。
4.展示你的激情
在 Unsplash 上由 Randalyn Hill 拍摄的照片
展示你对数据科学的热情。展示你对数据科学的热爱。凭借你新燃起的激情，你可以实现数据科学领域提供的任何东西。对数据科学充满热情对于在这一领域取得最终成功至关重要。
但是你如何在面试的有限时间里展示你对这个主题的热情呢？
虽然主要目标必须是回答特定的问题，但你可以利用这个机会展示你在有效完成的特定项目中为取得最佳结果付出了多少努力。你在解释简历上的特定项目时，回答的深度将向面试官展示你在学习和理解核心概念时所投入的热情和奉献精神。
在人力资源面试中，当被问及与数据科学相关的具体问题时，你也可以表现出你的热情和对该主题的巨大兴趣。因此，你对数据科学的热情不仅会改善你的结果，还会向你的雇主展示你在这一领域获得知识和完善的奉献精神。
对于每个有志之士来说，弄清楚他们是否真正对数据科学感兴趣是非常重要的。数据科学是需要个人对该主题充满热情和极大兴趣才能获得更好结果和生产力的领域之一。下面这篇文章列出了从事数据科学的十个错误理由。如果你仍然不确定自己是否能成为未来的数据科学家，我建议你看看下面的帖子。
</10-wrong-reasons-to-become-a-data-scientist-319531bb874e>
5.关注细节
数据科学是一门庞大的学科。这是一个庞大的领域，不是你可以在一天或几天内完成的。因此，对于每个数据科学爱好者来说，开始关注当前一轮技术面试中可能会问到的最重要的话题变得至关重要。
每个公司都有自己特定的技术技能要求，这些要求是对其计划雇佣的员工的期望。与其他概念相比，某个公司可能更关注自然语言处理任务。一些其他公司可能会专注于一种更坚实的计算机视觉基础和知识的方法。或者有可能一家公司只是希望你对基本的机器学习概念有一个坚实的基础理解。
为了以更清晰和简洁的方式解释我的观点，我将提供一个可能在现实生活场景中发生的简单示例。假设你有一轮技术面试，面试内容是你的计算机视觉知识。如果你知道这是你面试过程中将要涉及的话题，学会收集所有与你将要被测验的特定话题相关的重要信息。了解更多关于计算机视觉库和其他与这个概念相关的复杂细节。
要了解每个数据科学追求者和爱好者最好关注哪些主题，以尽快涵盖所有基本概念，请查看下面提供的文章，该文章详细介绍了这一主题。它涵盖了每个人都必须学习的一些概念的详细方法，以尽快掌握数据科学。
6.强烈诚实的态度
布鲁斯·马斯在 Unsplash 上的照片
在这些面试过程中，对数据科学采取乐观的态度和坚定、诚实的态度是最佳选择。确保保持一种直截了当的方法，并以简洁和精确的方式回答问题。尽量让你的解决方案切中要点，不要添加任何不相关的信息。
如果你不知道数据科学中某个特定主题的错综复杂的细节，那完全没问题。如果这个话题相当深入，并且你在准备面试的时候已经准备好了这个特定的话题，最好承认你对这个特定的话题没有一点头绪，以避免胡言乱语，让自己陷入麻烦。
如果你在面试中提到的关于数据科学的特定主题方面有少量的知识，那么一定要告诉面试官这不是你知识的主要基础。但是你还没有更深入地了解那个特定的概念。
确保你的细节是针对概念的当前方面的。一旦你确定你的信息是相关的，就要非常自信地告诉他们，并确保你说的是你有限的知识，以避免在你不熟悉的话题上提出额外的问题。
尽量让你的事实和信息与具体问题相关。保持你的回答切题。不要试图在特定的问题上走极端。LSTMs 的主题应该用与特定主题相关的所有重要元素来精确地解释。没人问你的时候不要碰 CNN 之类的其他概念。此外，对数据科学的态度要直截了当。
7.养成做简要笔记的习惯
凯瑟琳·拉威利在 Unsplash 上拍摄的照片
正如之前多次讨论的那样，数据科学是一个庞大的课题。如果你在几天后或者在接下来的一周有一个面试，并且你打算一口气做完所有的事情，祝你好运！这种情况发生的几率通常不高，因为在这段时间内要涵盖大量的内容。
然而，有一种做法可以最终帮助你获得富有成效的结果和更好的参与。做笔记，用你自己的话记下所有的基本概念，用一次阅读就能记住每一个概念的方式是非常有用的。你选择记笔记的模式对这个技巧的成功至关重要。
我的建议是，每当你开始准备数据科学的学习时，都要准备一个小本子。这本书将对你修正你需要的每一个概念至关重要。你可以选择每周或每月做一次，这取决于你对自己能力和记忆力的信心程度。这本书将作为你练习复习过程的一个重要方面。
修订和保持与数据科学主题的联系是数据科学的一个组成部分。数据科学是一个不断发展的领域，这一领域的持续发展和进步将在未来几年继续下去。因此，对于每个对该领域充满热情的数据科学爱好者来说，了解每个概念都是非常重要的，因为在不久的将来会有更多的概念出现。弄乱基础知识会让你在未来学习新的有趣的话题时很困难。
结论:
萨姆·麦克格在 Unsplash 上拍摄的照片
“相信你自己！对自己的能力有信心！如果你对自己的能力没有谦逊但合理的信心，你就不会成功或快乐。”
— 诺曼·文森特·皮尔
尽管在不久的将来，你计划参加的任何类型的面试都需要涵盖数据科学中的各种概念，但不可否认的是，本文中提供的技巧将帮助你以更高的成功率实现这一过程。我强烈建议你在面试过程中尝试这些技巧，以获得更好更有效的结果。
在这篇文章中，我还想提到的一个要点是，无论你在面试中是成功还是失败都没有关系。只要你知道你尽了最大的努力，每一次面试都应该被看作是一次经验的提升，是你寻求学习的东西。你将习惯于众多的面试环境，这有助于你找到一种更直截了当的方法来解决各种问题。
因此，总是尽你最大的努力，确保你生活或任何面试过程的主要目标是最终获得知识，并有效地提高你的各种技能。在数据科学和机器学习面试中，你的项目、简历、技能和有效的沟通将使你能够遇到任何困难的情况，并从这些情况中获得胜利。
如果你对这篇文章中提到的各点有任何疑问，请在下面的评论中告诉我。我会尽快给你回复。
看看我的其他一些文章，你可能会喜欢读！
</8-best-visualizations-to-consider-for-your-data-science-projects-b9ace21564a> </15-tips-to-be-more-successful-in-data-science-c58aa1eb4cae> </5-unique-use-cases-of-ai-that-might-surprise-you-22478aaaabaf> </10-best-free-websites-to-learn-programming-939ec029009b>
谢谢你们坚持到最后。我希望你们都喜欢这篇文章。祝大家有美好的一天！
在 Cognos Analytics 中设计更好的可视化效果的 7 个技巧
实践教程
帮助您使用 IBM Cognos Analytics with Watson 设计简洁有效的可视化效果的快速技巧
由 Carlos Muza 在 Unsplash 上拍摄的照片
设计仪表板和报告时，有效的可视化是关键。难以阅读的可视化会导致信息丢失和用户沮丧。
如今，有多种方法可以创建可视化——无论是使用 Python 和 R 等开源工具，还是 Tableau、Cognos Analytics 和 Qlik Sense 等商业智能工具。这些工具都有自己设计可视化的方式。
在本文中，我们将了解如何使用 IBM Cognos Analytics 和 Watson 来设计可视化，Watson 是一种自助式分析工具，用于通过仪表板、报告和交互式故事来创建和共享可视化。
继续阅读，寻找如何在 Cognos Analytics 中设计有效可视化的技巧。
提示 1:根据可视化中使用的数字变量对条形图中的值进行排序
下图显示了一家面包店的商品交易数量。使用此图表，很难确定哪些项目的交易比其他项目多，尤其是价值相近的项目。
按作者分类的图像:未排序的条形图，显示了按烘焙项目分类的交易数量
根据交易数量进行排序可以帮助查看者轻松识别和比较烘焙食品。如果使用一个有许多类别的变量，这是很重要的。
要对值进行排序:
- 选择可视化效果
- 选择字段选项卡
- 在长度下，选择排序和下降
按作者排序的图像:按数字变量排序的条形图，在本例中是事务数量
提示 2:当使用摘要可视化显示关键指标时，使用标题作为标签
摘要可视化是显示关键指标的好方法。为了增加好处，添加一个标题，并把它作为标签。在下面的例子中，左边的摘要可视化显示了默认的标题和标签。右边的视觉效果移除默认标签，并使用标题作为标签。这个简单的动作产生了更清晰、更容易理解的视觉效果。
图片作者。左图:显示总销售额的可视化摘要，应用了默认标题和标签。右图:移除了默认标签并调整了标题的摘要可视化效果。
要删除默认标签:
- 选择可视化效果
- 选择属性标签
- 取消选中图表部分下的显示标签
要格式化标题，请双击标题名称，并使用屏幕顶部的菜单栏来调整字体。
提示 3:给条形图和堆积条形图添加标签
条形图上的标签可以帮助查看者快速确定每个类别的价值。回到我们的面包店示例，让我们将标签添加到面包店商品交易的条形图中。
要向条形图添加标签:
- 选择可视化效果
- 选择属性选项卡
- 在图表部分选择显示数值标签
注意:标签可以放在每个条内，也可以放在每个条的外面。
作者图片:带标签的条形图
标签对于堆积条形图也很有用，可以像单个条形图一样应用。下面的堆积条形图显示了按客户类型和产品线划分的销售额。标签显示了每个产品线的百分比。
按作者分类的图像:带百分比标签的堆积条形图
提示 4:调整默认图例位置
在 Cognos 中，默认情况下，一些可视化自动在标题下显示图例。虽然图例包含有用的信息，但请考虑调整图例的位置。图例应该用来补充你的视觉化，而不是分散或从视觉化中拿走。将图例移至图表的右侧或底部，可让查看者将注意力集中在可视化效果上，同时在图例中仍有必要的可用信息。
在某些情况下，例如饼图，您可以完全删除图例，以便为可视化留出更多空间。
这是一个图例位于可视化顶部的示例。图例占据了大量的空间，从而将用户的注意力从可视化上引开。
按作者分类的图像:标题下方有图例、图形上方有图例的折线图
这是另一个例子，但是这次图例放在可视化的右边。我们可以看到，通过简单地调整图例的位置，我们的可视化变得不那么混乱，并且易于阅读。
作者图像:可视化右侧带有图例的折线图
要调整图例的位置:
- 选择可视化效果
- 选择属性选项卡
- 在图例部分下选择右为图例位置
技巧 5:给文本表格添加颜色
可视化数据不仅限于图表！也有文本表格的用例。添加颜色可以创造深度，让你的桌子更有新鲜感。下表显示了各种股票的开盘价、收盘价和日变化。最后一列应用了条件格式，以根据值更改文本颜色。
按作者排序的图像:在日期更改列上应用了条件格式的文本表格
要应用条件格式:
- 选择可视化效果
- 选择属性选项卡
- 在条件色下选择想要格式化的变量。在这种情况下，选择的变量是日变化。
- 将刻度改为数字
- 选择添加规则。在这种情况下，应用了两个规则。
作者图片:应用于日期变更变量的条件格式规则示例
提示 6:删除不必要的网格线
默认情况下，一些可视化显示网格线。使用双轴图表时，网格线很有帮助，但在某些情况下，它们会造成混乱。删除网格线是减少可视化效果混乱的一种快速简单的方法。
例如，下面的可视化显示了一段时间内 IBM 股票的收盘价。此可视化效果有网格线。
作者图片:带网格线的折线图
移除网格线减少了可视化中的噪声。
作者图片:没有网格线的折线图
要从可视化中删除网格线，请执行以下操作:
- 选择可视化效果
- 选择属性选项卡
- 取消选中图表部分下的显示网格线
提示 7:当可视化大量类别时，选择树形图而不是饼状图
饼图非常适合显示比例，或部分到整体的关系；然而，当用于包含几个类别的变量时，它们会变得难以阅读，尤其是当许多类别的值接近时。
以下面的饼图为例。此视觉效果的目标是显示每个面包店项目的交易数量。从这个饼图中，我们可以立即确定咖啡和面包是交易量最大的两种面包店商品，并且咖啡交易量大于面包交易量。然而，我们无法区分图上较小的类别。这是因为大脑很难处理角度，所以需要更多时间来确定哪个切片是最大或最小的。
按作者分类的图像:饼图显示每个烘焙项目的交易数量
另一方面，树形图使用矩形来表示每个类别的大小，最大的类别在可视化的左上角，最小的类别在可视化的右下角。与饼图相比，每个矩形有更多的空间来添加类别标签。
按作者分类的图像:按面包店项目显示交易数量的树形图
下次使用 Cognos Analytics 创建可视化时，请记住这些提示！了解更多关于 IBM Cognos Analytics with Watson 的信息并免费试用这里。
Payal 是 IBM 的一名数据科学家。在业余时间，她喜欢阅读、旅游和写作。如果你喜欢她的作品， 在这里订阅 到她的列表，千万不要错过一个故事！
以上文章是个人观点，不代表 IBM 的立场、策略或观点。
提升数据科学 Python 代码的 7 个技巧
让你的生活更轻松
照片由 rodrigomullercwb 在 Pixabay 上拍摄
开始时编写 Python 代码很容易，但是随着您向工具箱中添加更多的库，您的脚本可能会包含不必要的代码行，变得很长，看起来很乱。尽管代码仍然可以完成工作，但从长远来看，它会给你带来一些麻烦。
我是在多次用 Python 清洗、扯皮、做数据分析之后，才知道这一点的。幸运的是，这些年来我的 Python 代码一直在改进，在本文中，我将与您分享 7 个技巧来提高您的 Python 代码水平，并使您在使用 Python 进行数据科学时更加轻松。
这涵盖了我们每天做的事情，比如修改熊猫数据帧中的值、连接字符串、读取文件等等！
1.使用 Lambda 修改熊猫数据帧中的值
假设我们有下面的df数据帧。
data = [[1,2,3], [4,5,6], [7,8,9]]
df = pd.DataFrame(data, columns=[0,1,2])IN[1]: print (df)OUT[1]: **0 1 2**
**0** 1 2 3
**1** 4 5 6
**2** 7 8 9
现在出于某种原因，您需要将值‘01’加到列0中的数字上。一种常见的方法是定义一个执行此任务的函数，然后使用apply函数来修改列的值。
**def** add_numbers(x):
**return** f'{x}01'df[0] = df[0].apply(add_numbers)IN[1]: print (df)OUT[1]: **0 1 2**
**0** 101 2 3
**1** 401 5 6
**2** 701 8 9
这并不复杂，但是为您需要在数据帧中进行的每个更改创建一个函数是不实际的。这就是 lambda 派上用场的时候了。
lambda 函数类似于常规的 Python 函数，但是它可以在没有名称的情况下定义，这使得它成为一个看起来很不错的一行程序。前面使用的代码可以用下面的代码来简化。
df[0] = df[0].apply(**lambda** x:f'{x}01')
当您不知道是否有可能访问一个系列的属性来修改数据时，Lambda 变得非常有用。
假设列0包含字母，我们想将它们大写。
# if you know the existence of the .str, you can do it this way
df[0] = df[0].str.title()# if you don't know about .str, you can still capitalize with lambda
df[0] = df[0].apply(**lambda** x: x.title())
2.使用 f 字符串连接字符串
字符串连接是 Python 中非常常见的操作，可以用不同的方式完成。最常见的方法是使用+运算符；然而，这个操作符的一个大问题是我们不能在字符串之间添加任何分隔符。
当然，如果您想要连接“Hello”和“World”，一个典型的解决方法是添加一个空格分隔符(" ")。
print("Hello" + " " + "World")
这就完成了工作，但是为了编写更可读的代码，我们可以用 f 字符串来代替它。
IN[2]: print(f'Hello World')
OUT[2]: "Hello World"
在一个基本的例子中，这似乎是不必要的，但是当涉及到连接多个值时(正如您将在技巧#3 中看到的)，f 字符串将使您免于编写+ “ “ +很多次。我不知道过去我写了多少次+操作符，但是现在没有了！
连接字符串的其他方法是使用join()方法或format()函数，但是 f-string 在字符串连接方面做得更好。
3.用 Zip()函数遍历多个列表
你有没有想过在 Python 中遍历多个列表？当你有两个列表时，你可以用enumerate来完成。
teams = ['Barcelona', 'Bayern Munich', 'Chelsea']
leagues = ['La Liga', 'Bundesliga', 'Premiere League']**for** i, team **in** enumerate(teams):
league = leagues[i]
print(f'{team} plays in {league}')
然而，当你有两个或更多的列表时，这就变得不切实际了。更好的方法是使用zip()功能。zip()函数获取可重复项，将它们聚集在一个元组中，然后返回。
再加一个单子，看看zip()的威力！
teams = ['Barcelona', 'Bayern Munich', 'Chelsea']
leagues = ['La Liga', 'Bundesliga', 'Premiere League']
countries = ['Spain', 'Germany', 'UK']**for** team, league, country **in** zip(teams, leagues, countries):
print(f'{team} plays in {league}. Country: {country}')
上面代码的输出如下。
Barcelona plays in La Liga. Country: Spain
Bayern Munich plays in Bundesliga. Country: Germany
Chelsea plays in Premiere League. Country: UK
你注意到我们在这个例子中使用了 f 弦吗？代码变得可读性更强了，不是吗？
4.使用列表理解
清理和争论数据的一个常见步骤是修改现有列表。假设我们有以下需要大写的列表。
words = ['california', 'florida', 'texas']
大写words列表中每个元素的典型方法是创建一个新的capitalized列表，执行一个for循环，使用.title()，然后将每个修改后的值追加到新列表中。
capitalized = []
**for** word **in** words:
capitalized.append(word.title())
然而，Pythonic 式的方法是使用列表理解。列表理解有一个制作列表的优雅方法。
您可以用一行代码重写上面的for循环:
capitalized = [word.title() for word in words]
正如你所看到的，我们可以跳过第一个例子中的一些步骤，结果是一样的。
5.对文件对象使用 With 语句
当我们处理一个项目时，我们经常读写数据到文件中。最常见的方法是使用open()函数打开一个文件，这将创建一个我们可以操作的文件对象，然后作为一个好的实践，我们应该使用close()关闭文件对象
f = open('dataset.txt', 'w')
f.write('new_data')
f.close()
这很容易记住，但有时在编写代码几个小时后，我们可能会忘记用f.close()关闭f文件。这时with语句就派上用场了。with语句将自动关闭文件对象f，如下图所示。
with open('dataset.txt', 'w') as f:
f.write('new_data')
这样，我们可以保持代码简短。
虽然你不需要这个来读取 CSV 文件，因为你可以很容易地用熊猫pd.read_csv()来读取它们，但这在读取其他类型的文件时仍然很有用。例如，我经常在腌制物品时使用它。
import pickle# read dataset from pickle file
with open(‘test’, ‘rb’) as input:
data = pickle.load(input)
6.停止使用方括号来获取词典条目。使用。请改为 get()
假设你有下面的字典:
person = {'name': 'John', 'age': 20}
分别做person[name]和person[age] 我们很容易得到姓名和年龄。然而，如果出于某种原因，我们想得到一个不存在的键，像'salary',运行person[salary]将提高一个KeyError。
这就是get()方法有用的时候。如果关键字在字典中，那么get()方法返回指定关键字的值，但是如果没有找到关键字，Python 将返回None。多亏了这一点，你的代码不会中断。
person = {'name': 'John', 'age': 20}print('Name: ', person.get('name'))
print('Age: ', person.get('age'))
print('Salary: ', person.get('salary'))
输出如下所示。
Name: John
Age: 20
Salary: None
额外收获:多重任务
您是否曾经想要减少用于创建多个变量、列表或字典的代码行？嗯，你可以很容易地用多重作业来完成。
# instead of doing
a = 1
b = 2
c = 3# you can do
a, b, c = 1, 2, 3# instead of creating multiple lists in different lines
data_1 = []
data_2 = []
data_3 = []
data_3 = []# you can create them in one line with multiple assignments
data_1, data_2, data_3, data_4 = [], [], [], []# or use list comprehension
data_1, data_2, data_3, data_4 = [[] for i in range(4)]
就是这样！明智地使用这 7 个技巧来提升你的 Python 代码。
与 3k 以上的人一起加入我的电子邮件列表，获取我在所有教程中使用的 Python for Data Science 备忘单(免费 PDF)
如果你喜欢阅读这样的故事，并想支持我成为一名作家，可以考虑注册成为一名媒体会员。每月 5 美元，你可以无限制地阅读媒体上的故事。如果你用我的链接注册，我会赚一小笔佣金。
https://frank-andrade.medium.com/membership
数据科学家用来提高效率的 7 种工具
让您的工作流程更简单、更快速、更省时。
阿尔瓦罗·雷耶斯在 Unsplash 上拍摄的照片
在任何数据科学项目的进展过程中，大多数数据科学家倾向于利用工具和小工具来帮助他们更快、更有效地实现目标。他们使用这些工具来加速日常任务，以节省他们的精力和脑力，为他们试图解决的当前问题找到解决方案。
由于这种加快项目工作流程的愿望，有如此多的数据科学工具可供选择，无论哪种都适合手头的任务。相信我，当我这么说的时候，有上百种工具可供你选择来完成你的项目；在项目结束时，你会发现你使用了多个这样的工具来完成一个项目。
</5-data-science-programming-languages-not-including-python-or-r-3ad111134771>
由于任何数据科学项目都由不同的步骤组成，从收集数据到清理、分析和可视化数据，每个步骤都有专门设计和开发的工具。自动从网络上收集数据的工具，或者可视化数据并帮助您讲述隐藏在其中的故事的工具，或者帮助您清理数据并在分析中使用最相关部分的工具。
本文将浏览数据科学工具目录，并讨论当今数据科学家最常用的 7 种工具。也许这些工具可以帮助你完成下一个项目。
№1: IBM 沃森工作室
我们列表中的第一个工具是怪物工具， IBM Watson Studio 。Watson Studio 是一个工具和 API 的集合，旨在加速包括机器学习和深度学习技术在内的应用程序。IBM Watson Studio 根据您的需求、项目规模和您的团队提供免费和付费计划。
Watson Studio 提供了许多关于各种概念和 API 的教程。这些教程大部分都很灵活，可以在你的浏览器上完成，所以不需要任何安装。Watson Studio 提供了准备、管理和分析数据的工具。它还提供了大量的数据集、模型和教程供您在项目中使用。
№2:亚马逊红移
数据科学就是关于数据的，在大多数项目中，你需要处理的数据量是相当大的。我们名单上的下一个工具， Amazon Redshift ，是一个云服务，它允许你扩展你的项目，以便它们可以处理大规模数据集。一旦您的数据上传到 Redshift，您就可以对其进行分析和查询。
使用 Amazon RedShift 作为您的数据之家有很多好处；您可以加密您的数据以保持其安全性，这些好处包括。您可以轻松增加数据集中的结点数量，并且该工具没有前期成本。即使你使用付费计划，这些工具也提供按需定价，以消除长期承诺。
</5-new-data-science-books-that-you-should-consider-reading-c90aec1d5b0d>
№3:谷歌大查询
我们列表中的下一个工具是另一个数据存储和查询平台，即 BigQuery。 Google 的 BigQuery 是一个可扩展的无服务器数据仓库工具。该工具旨在帮助数据科学家对其数据进行高效的分析。该工具通过快速轻松地创建仪表板和报告，帮助开发人员发现模式和趋势。
使用 BigQuery 的开发人员之所以这样做，是因为高效地分析数据是多么的快速和简单，而且由于仓库是无服务器的，它的伸缩是多么的无缝。BigQuesry 是一项付费服务，但他们承诺，他们提供的服务价格是其他服务无法比拟的。
№4:微软 Azure
接下来是微软 Azure 。微软 Azure 是一个非常知名的云服务，它的功能和用户群都在增长。该工具为开发人员提供了许多选项，可以轻松地设计、构建和部署应用程序。微软 Azure 是工具的集合，有些存储数据，有些分析，有些集成了 AI 和机器学习技术。
微软 Azure 提供的所有工具都采用按需付费模式定价，只允许你按需付费。不仅如此，你还可以使用 Azure 成本管理工具来优化你为微软 Azure 服务支付的费用。
</6-data-science-slack-workshops-you-need-to-join-b0c00952105d>
№5:雪花
或者说最后一个数据仓库是雪花。雪花是一个关系型 ANSI SQL 数据仓库，开发人员可以使用它来优化与数据库的通信，从读取项目到删除项目，甚至执行一些分析查询。
使用雪花有很多优点，包括消除任何管理需求，因为雪花中没有基础设施需要管理。Snowflake 还支持您可能在项目中使用的所有形式的数据，对缩放和共享数据的支持似乎很简单。
№6: Alteryx
任何数据科学项目的主要步骤之一是数据分析。下一个工具是 Alteryx ，这是一个数据分析工具，可以让你搜索数据中的相关信息，并轻松找到和管理数据中的任何信息。它允许您同时分析来自多个来源的数据；您可以从 Excel 和 Hadoop 中导入数据，并在同一位置进行分析。
Alteryx 拥有 60 多个内置工具，可以满足从回归到聚类和分类的所有数据分析需求。您还可以使用 Python 或 r 在 Alteryx 中构建自己的工具。Alteryx 还允许您通过以 Qlik、Microsoft Power BI 和 Tableau 等常用格式创建报告来可视化数据。
</9-comprehensive-cheat-sheets-for-data-science-46005d72b485>
№7:qlink
列表中的最后一个工具是数据可视化工具。数据可视化是任何数据科学项目的重要组成部分；它可以决定你项目的成败。这个列表中的数据可视化工具是 Qlik 。Qlik 是一种可视化分析工具，允许您创建仪表板和可视化工具，以帮助讲述您的数据故事。
通过 Qlik，开发人员可以使用简单快速的拖放界面创建交互式可视化效果。Qlik 不仅仅是一个数据可视化工具；它是一个集中的中心，使您能够统一来自不同数据库的数据，并对其内容进行可视化分析。您还可以将 Qlik 嵌入到您的应用程序中，用于自动数据捕获和分析。
最后的想法
当您进入数据科学领域时，通常会从学习基本概念和要使用的编程语言开始，无论是 Python、R、Julia 还是任何其他语言。但是，当你开始构建现实生活中的应用程序时，你会意识到在任何项目中你必须完成的大多数任务都是如此的例行公事，并不需要你的全部精力。
问题的主要部分——应用模型、培训、测试和优化它们——需要您的全部注意力，而且这可能是需要最长时间才能完成的部分。这就是为什么开发了许多工具来帮助数据科学家有效地完成他们的项目，而不在日常任务上浪费任何时间或脑力。
</6-machine-learning-certificates-to-pursue-in-2021-2070e024ae9d>
在本文中，我们讨论了数百种工具中的 7 种，这些工具是数据科学家用来加快工作流程并帮助他们高效、轻松地构建项目的最常用工具。我希望你能在你的下一个项目中利用这些工具，我希望它们能帮助你更快地达到你的目标。
极其高效的数据科学家的 7 个特征
办公时间
要成为一名高效的数据科学家，你必须首先变得高效
对数据科学的一个常见抱怨是，工作中的许多日常任务是重复的、多余的、耗时的。
这种繁忙的工作经常被引用为数据科学家不满意他们工作的许多原因之一，他们中的许多人认为他们将永远从事令人兴奋的项目和完成对公司至关重要的分析。
然而，当现实出现时，意识到很多工作可能是单调的，并不像解决现实世界的大问题那样令人兴奋。
许多人谈论成为高效数据科学家的重要性，但很少有人讨论人们如何才能成为高效数据科学家。效率是有效性的支柱之一，随着那些无聊的任务成为过去(或者至少是自动化的未来)，效率会带来工作满意度的提高。
1.他们自动化重复的任务。
数据科学建立在重复性任务的基础上，包括获取、准备和清理数据的基础。数据科学家将 80%的时间花在这些任务上，这是一个普遍的经验法则。
不幸的是，这种重复且通常令人麻木的任务占用了太多时间，尤其是当数据分析、可视化和建模等有趣的事情最初让人们进入数据科学时。
虽然获取、准备和清理数据对于项目的成功至关重要，但它们并不是产生特定 ROI 的活动——它们只是最终获得 ROI 的任务。将大部分时间花在有明确投资回报的任务上，并使用自动化来处理其他任务，难道没有意义吗？
自动化那些占用你大部分时间的低投资回报率的任务会让你变得更有效率，在日常任务上花费更少的时间。虽然每个项目都有关于数据收集和清理的细节，但是一旦确定了您的需求，仍然有可能自动化这个过程。
如何自动收集数据:
如何自动化数据清理:
如何自动化代码检查:
2.他们用最简单的工具做这项工作。
信不信由你，并不是每个数据分析都需要机器学习和人工智能。
解决问题最有效的方法是使用最简单的工具。
有时，一个简单的 Excel 电子表格可以产生与使用深度学习的大型复杂算法相同的结果。
通过从一开始就选择正确的算法和工具，数据科学项目变得更加高效。虽然用一个超级复杂的工具给每个人留下深刻印象是很酷的，但从长远来看，当使用一个更简单、更高效的解决方案可以花费更少的时间时，这是没有意义的。
这里有一些资源可以帮助你为下一个数据科学项目选择最好的工具和算法:
</10-tools-i-use-to-streamline-my-data-science-learning-experience-1501ddef4f0>
3.它们遵循严格的编码结构。
第一次就把工作做好是完成任何项目最有效的方法。
就数据科学而言，这意味着使用严格的结构编写代码，使其易于回顾、调试、更改，甚至使您的代码为生产做好准备。
清晰的语法指南使每个人都有可能理解其他人的代码。然而，语法指南不仅仅是为了让你理解别人的鸡毛蒜皮——它们也是为了让你专注于编写最干净、最有效的代码。
没有什么比编码了整个项目，然后不得不返回并重构所有代码以遵循公司指导方针更糟糕的了。
通过熟悉最佳编码实践、最佳软件工程实践以及来自您公司的特定语法指南和要求来节省您的时间。
这里有一些资源可以帮助你遵循最佳实践:
4.他们身边有一个团队可以帮助他们解决问题。
没有人是海洋，数据科学家也不例外。
虽然解决一个难题会令人兴奋，令人难以置信地满足，但如果它花费了你不必要的时间，那可能不是你的最佳利益所在。
我记得有几次我被困住了，拒绝寻求帮助。在几个小时(当然有时是几天)试图解决问题的过程中，我会屈服，去问别人，却发现他们在不到五分钟内给我的解决方案只需要几秒钟就能实现。
换句话说，最高效的数据科学家不害怕寻求帮助，此外，他们周围有一个团队，里面都是能够给他们所需答案的人。A 团队环境差是这么多数据科学家离职的原因之一，这进一步凸显了你身边有一个好团队的重要性。
这里有一些资源可以帮助你开始建立更好的数据科学团队:
https://www.kdnuggets.com/2019/04/why-data-scientists-need-work-groups.html
5.他们留出时间来学习新的东西和完善自己。
自我提升是效率的基石之一。没有改进，就不可能有效率的提高。
最高效的数据科学家会花时间去学习新事物，完善自己。
无论是完成每周一次的文献综述，还是每周抽出几个小时来学习 MOOC，随着数据科学家的知识库不断扩大，他们变得更加高效。
数据科学是一个快速变化的领域，每年都会出现新的语言，不断发布大量关于新技术的学术论文，不断增长的社区聚集在一起，分享如何以不同方式做事的新见解。
保持领先和相关的唯一方法是留出专门的学习时间。
你可以从每周安排几个小时的专门学习时间开始，并为自己设定每节课的任务。例如，在周三的一个小时里，你阅读并评论一篇关于机器学习的新论文。在周五的一个小时里，你将练习实现生成性对抗网络(GANs)。最后，在周日，你做一个个人项目或完成黑客等级或 Kaggle 挑战的编码。
通过留出一小块时间专门做任务，养成每周自我改善的习惯会变得更容易。
这里有一些资源可以让你从文献综述、个人项目和 MOOCs 开始。
6.他们使用最佳的可视化方法来避免数据失真。
正如我前面提到的，提高效率的最快途径是第一次就把工作做好。
这不仅意味着使用正确的语法结构进行编码，还意味着从一开始就使用正确的可视化来确保不会意外地扭曲数据。
选择正确的可视化不仅对数据完整性很重要，对理解数据告诉你什么也很重要。由于数据可视化通常是在任何建模或分析之前首先完成的任务之一，因此第一次就把它做好非常重要，这样您就知道自己在处理什么了。
这里有一些资源可以帮助你理解不同类型的数据可视化以及何时使用它们:
7.他们在编写任何代码或清除任何数据之前都会制定一个攻击计划。
当我在大学学习软件开发时，我学到的最好的技巧之一就是在编写任何代码之前都要制定一个计划。
无论是流程图、一步一步的思考过程、伪代码还是清单，在做任何与数据科学相关的事情之前有一个攻击计划对项目的成功和效率至关重要。
我记不清有多少次我一直在编码(没有计划)，然后当我正在构建一些复杂的逻辑时，有人来打断我。一旦我回到工作岗位，我意识到我已经失去了我的思路，不知道我需要从那里去哪里。如果我有一个计划，我就能从我停止的地方重新开始。
计划不仅对维持你的思维过程有用，当事情出错时，它们对解决问题也至关重要。有一个计划可以帮助你回顾你所采取的步骤，这对于识别错误或者你的逻辑不太适用的地方是很有用的。
有计划会让你更快更有效地编码，并且当你的思路不可避免地离开车站时，你不会浪费宝贵的时间试图跳回你的思路。
这里有一些资源可以帮助你写出更好的流程图和伪代码来提高你的编码效率:
奖金:8。他们优化日常工作流程。
数据科学是那些期望你在任何一天都完美地完成许多不同任务的职业之一。然而，这些任务中的大多数需要不同的技能，这使得从一个任务跳到另一个任务变得困难。此外，当你忙于不同项目的不同方面时，这通常涉及到一个完全的思维转变。
解决方案是优化您的日常工作流程，以提高效率和生产力。不，这并不意味着多任务处理。这意味着使用诸如任务分批、时间分段或日主题化之类的系统，在这些系统中，你在给定的一段时间内处理相同类型的任务，并且只处理这些类型的任务。
简而言之，将你的日常任务分批次进行，让你不必做必要的精神体操来转换你的思维过程，以适应完全不同的任务。
有几种不同的方法可以对任务进行批处理:
- 按类型批量处理任务(例如:从早上 9 点到晚上 12 点，您完成所有项目的数据清理)
- 按焦点批量任务(例如:从早上 9 点到晚上 12 点，你完成与项目 X 相关的任务)
第一种类型的例子允许你保持数据清理的心态，为你的所有项目做所有的数据清理。第二种类型的例子可以让你完全专注于项目 X，这样你就可以完成当天与项目 X 相关的所有任务。根据你的最佳工作方式，你可能会发现在一段时间内专注于一种特定类型的任务或一个特定的项目对你来说是最有效的。
这里有一个很好的资源，可以让你更深入地了解时间块、任务批处理和日主题化:
https://todoist.com/productivity-methods/time-blocking
最后的想法。
在竞争异常激烈的数据科学领域，数据科学家的评判标准是他们对公司产生积极影响的能力。这种积极影响伴随着效率的提高，而效率的提高反过来又会带来成效。
通过实现高效数据科学家的上述特征，你将成为一名数据科学家，能够带来公司所寻求的重要影响。
作为一名自由数据科学家，你可以做 7 种类型的工作
建立一个更好的投资组合，发展你的专长，赚钱
戴维·巴拉尔迪在 Unsplash 上拍摄的照片
说实话，在 2021 年做一名数据科学家并不容易。虽然对数据科学家的需求仍然很高，供应也很高，但在数据科学领域找工作可能非常具有挑战性，有时会令人沮丧。如果你是一名数据科学新手，刚刚完成基础知识的学习，建立了几个项目，并准备申请工作，那么你知道找工作并不那么容易。
即使是入门级的数据科学工作也需要一些经验——我不会讨论这有什么意义。但是，要获得找工作所需的经验，你需要有一份工作或一个令人印象深刻的项目组合。那么，如果没有在工业界或学术界获得数据科学的职位，如何获得这种经验呢？
当今数据科学家的最佳选择之一，无论是新手还是专家都是自由职业者。作为一名数据科学自由职业者，你有很多自由来选择你的项目，控制你的时间和工资。对于通过构建真实项目来寻找更多实践经验的初学者来说，这也是一个很好的选择。
</7-ways-to-take-your-visualizations-to-the-next-level-4b68cb0f34b4>
对于那些想自己当老板或想在其他国家远程工作的人来说，这也是一个很好的选择。作为一名自由职业数据科学家，你会遇到不同类型的工作(自由职业工作/项目)，你可以根据自己的喜好和知识基础申请/投标。
如果你正在寻找一份自由职业的数据科学工作，你可以在像 UpWork 、 Topal 、 Angelist 、编码忍者这样的网站上找到工作，或者简单地使用 LinkedIn Jobs finder 和工作类型 contract 在这篇文章中，我们将探索你可能在这些网站上找到的一些选项。
№1:数据可视化项目
我们将从你能找到的最普通的工作开始，它需要一点创造力，可视化项目。许多初创公司和个人都在寻找数据科学家来创建高效的可视化，从而使数据交流更容易、更好。
对于数据可视化项目，您会发现使用特定技术(如 Tableau、Power bi 或任何其他工具)创建交互式图形和仪表板的请求。数据可视化工作平均起价为 58 美元/小时或更高，这取决于经验水平、质量和工作速度。
</9-free-quality-resources-to-learn-and-expand-your-python-skills-44e0fe920cf4>
№2:教学和辅导
接下来是我个人最喜欢的一个选项，也是我做得最多的一个选项，即教授或辅导数据科学主题。如果您了解数据科学的基础知识，或者您喜欢深入的主题，您可以主动向他人教授这些主题。
该选项还包括指导和监督项目。我发现教学是帮助他人更好地理解数据科学和编程主题，同时提高自己水平的最佳方式。您可以为会话指定小时费率，通常从 15 美元/小时开始，一直到 60 美元或 80 美元。基于客户需求的会话持续时间。
№3:数据清理
在处理数据科学项目时，最重要的第一步是数据清理，这基本上意味着将数据转换成一种可以在以后用于实现不同算法的格式。不幸的是，这项任务通常是例行公事，令人厌烦，一些数据科学家可能会雇用其他人来完成这项任务，以便专注于建模。
数据清理工作通常需要一些数据操作知识，能够获得不同列之间的关系，以及如何发现异常和趋势。根据数据集的复杂程度，这类任务的起薪从 50 美元到 90 美元不等。
</6-lesser-known-data-science-blogs-that-are-worth-following-cc42924abb13> [## 值得关注的 6 个鲜为人知的数据科学博客
towardsdatascience.com](/6-lesser-known-data-science-blogs-that-are-worth-following-cc42924abb13)
№4:构建数据模型
接下来是一种类型的工作，它将帮助你建立更多的实用知识和更强大的投资组合，即设计、构建和开发数据模型。你将需要实现机器学习、人工不雅或大数据算法来完成这种 gig 中的特定任务。
这可能还包括构建机器人、推荐系统或任何其他特定的数据科学应用。这种项目的好处是它可以非常有利可图，有些项目可以赚几千美元，有些可能需要几个月的承诺。
№5:研究
这是一种特殊的演出；它更侧重于进行客户研究，这将有助于设计模型和提取数据。这包括进行调查和分析结果。它还可能包括创建原型和为特定问题提出实现解决方案。
如果你喜欢处理数据，问一些能让项目更好的问题，并帮助客户获得他们需要的产品，那么这种类型的工作可能适合你。根据你的经验和项目的复杂程度，这样的工作报酬从 50 美元到 200 美元不等。
</5-python-books-to-transfer-your-code-to-the-next-level-a5af0981e204> [## 5 本 Python 书籍，让你的代码更上一层楼
towardsdatascience.com](/5-python-books-to-transfer-your-code-to-the-next-level-a5af0981e204)
第六名:咨询
接下来是一份工作，主要面向有经验的数据科学家或在学术界或研究领域工作的人，这就是咨询。在咨询活动中，客户选择你是基于你在某个特定主题上的专长。他们会问你关于可能的途径和解决方案的问题，寻求反馈，甚至可能进行一些分析。
这种工作是你能找到的报酬最高的自由职业之一，你可以根据你认为合适的东西来设定每小时的报酬，如果客户认为这对你的知识来说是一个公平的价格，他们会很乐意支付。
№7:内容作者
最后但同样重要的是，一份与教学相关的工作，也是我最喜欢的工作，内容写作。数据科学和编程越来越受欢迎，各个层次的人都在寻找资源来扩展他们的知识和学习新的主题。他们可以这样做的一个方法是阅读博客帖子或技术教程。
很多发布技术内容的网站，总是在寻找能够用通俗易懂的方式沟通复杂信息的人。他们通常会为这些文章支付一大笔钱，通常从 75 美元到 500 美元不等，甚至根据文章的长度和质量支付更多。
最后的想法
如果你曾经试图寻找任何职位，甚至不仅仅是数据科学职位，那么你一定会发现找到一个职位有点挑战性。通常，你申请工作，你可能会幸运地得到回复，也可能没有回音。这些要求通常是不切实际的；你寻找需要经验的入门工作，而没有工作你是得不到经验的。连实习都不好落地。
那么，如果你找不到工作，如何获得经验和发展技能呢？你可以这样做的一个方法是从做一名自由职业的数据科学家开始。作为一名自由职业的数据科学家，你可以选择你从事的项目；你可以指定你的工资，并建立一个投资组合，然后你可以用它来申请行业角色。
</9-comprehensive-cheat-sheets-for-data-science-46005d72b485>
在本文中，我们介绍了一些你可以在网站上找到的最常见的数据科学工作，你可以申请。然后，根据你的喜好和你的目标，是建立更多的项目，增强你的学习能力，还是赚些钱，你可以选择我们经历过的角色中哪些最符合你的喜好。
7 种不常见但有用的熊猫功能
提高你的熊猫技能的功能
埃里克·麦克林在 Unsplash 上的照片
Pandas 是最流行的数据分析库之一。有许多 Pandas 函数和方法可以简化和加快数据清理和分析过程。
Pandas 还提供了一些不常见的功能，但对于某些任务来说很方便。在本帖中，我们将介绍 7 种不常见的熊猫功能。
将要讨论的功能有:
- 夹子
- evaluate 评价
- 组合 _ 优先
- 改变
- 熔化
- 差速器
- 变化
我们总是开始导入依赖项。
import numpy as np
import pandas as pd
1.夹子
Clip 函数根据给定的上限值或下限值修剪数据帧。它不会删除超出上限值或下限值指定范围的行。相反，如果某个值在边界之外，clip 函数会使它们等于适当的边界值。
考虑下面的数据帧。
(图片由作者提供)
假设我们不希望有任何负值，希望它们等于零。这可以通过将削波函数的下限参数设置为 0 来实现。
df.clip(lower=0)
(图片由作者提供)
所有负值现在都等于零。我们也可以指定一个上限。例如，我们可以将值调整到 0 和 1 之间。
df.clip(lower=0, upper=1)
(图片由作者提供)
2.evaluate 评价
eval 函数允许通过将操作作为字符串传递来操纵或修改数据帧。
例如，下面的代码将修改“可乐”中的值。
df.eval("cola = cola * 10")
(图片由作者提供)
我们还可以创建一个新列:
df.eval("new = cola * colb")
(图片由作者提供)
需要注意的是，我们需要设置 inplace 参数来保存更改。否则，eval 函数将返回 dataframe 的修改版本，但不会更改原始版本。
3.组合 _ 优先
combine_first 函数通过使用一个数据帧中的值来更新另一个数据帧中缺少的值。匹配标准是行和列的位置。
考虑以下两个数据帧。
(图片由作者提供)
我们可以根据第一个数据帧更新第二个数据帧中缺失的值。
df2.combine_first(df1)
(图片由作者提供)
4.改变
transform 函数根据给定函数修改数据帧中的值。它可以是简单的聚合或 lambda 表达式。
考虑下面的数据帧。
(图片由作者提供)
我们可以通过使用变换函数来取每个值的对数。
df.transform(lambda x: np.log(x))
(图片由作者提供)
transform 函数的一个有用特性是它接受多个函数。我们可以在下面的列表中指定它们。
df.transform([lambda x: np.log(x), np.sqrt]
(图片由作者提供)
5.熔化
melt 函数将数据帧从宽格式转换为长格式。在宽格式中，相似的变量表示为单独的列。另一方面，long 格式包含一个存储这些变量的值的列和另一个存储变量名称的列。
对于某些任务，最好使用长格式的数据帧。melt 函数为这种转换提供了一种非常简单的方法。当我们做一个例子的时候会更清楚。
考虑以下宽格式的数据帧。
(图片由作者提供)
数据框包含一些人的日常测量。可以使用 melt 函数将其转换为长格式，如下所示。
df_long = pd.melt(df, id_vars='name')df_long.head(10)
(图片由作者提供)
6.差速器
diff 函数用于根据轴参数计算两个连续行或列之间的差异。
考虑下面的数据帧。
(图片由作者提供)
我们希望创建一个新列，其中包含“colc”中连续值之间的差异。
df['diff_c'] = df['colc'].diff()df
(图片由作者提供)
因为第一行没有任何先前的行，所以 diff_c 列的第一个值为 null。
7.变化
shift 函数可用于移动数据帧的索引。这对于时间序列数据尤其有用。
考虑以下带有日期时间索引的数据帧。
(图片由作者提供)
我们可以通过指定正或负的周期数来使用 shift 函数。
df.shift(3)
(图片由作者提供)
如果我们经过一个负周期，数值将向相反的方向移动。我们还可以指定一个值来代替由于移位而产生的空值。
df.shift(-3, fill_value=0)
(图片由作者提供)
结论
我们在这篇文章中所涉及的只是 Pandas 在数据分析过程中的一小部分能力，但是对于您的任务肯定是有用的。
试图一下子全部学会是不合理的。相反，学习小块和通过实践吸收信息将帮助你建立全面的数据分析技能。
感谢您的阅读。如果您有任何反馈，请告诉我。
Python 正则表达式需要学习的 7 个有用技巧
用它们编写功能强大、可读性强的正则表达式
正则表达式(又名 Regex)是任何编程语言中最重要和最常见的语言之一。当然，这也适用于 Python。与其他编程语言相比，Python 有一些非常独特的正则表达式使用模式。
在本文中，我为你整理了 7 个关于 Python 中正则表达式的有用技巧。它们要么是可以提高生产率、解决一些复杂问题或提高代码可读性的小技巧。希望它们会有所帮助！
1.始终使用“r 弦”
照片由 PublicDomainPictures 在 Pixabay 上拍摄
很多学习者都知道在定义正则表达式模式时应该使用“r-string”。但是，我发现很多人不知道原因。一些学习者认为“r-string”是“regex string”，这是完全错误的。它应该是“原始字符串”。
就像其他编程语言一样，Python 在字符串中有“转义”机制。例如，当我们想要一个带引号的字符串时，它们必须被转义以让编译器知道字符串不应该结束，引号只是字符串的一部分。
s = 'I\'m Chris'
当然，不仅仅是引号可以被转义，还有很多其他的场景我们不得不使用反斜杠。例如，以下字符串中的\n将被解释为“new-line”。
print('a\nb')
如果我们想让\n成为字符串的一部分，换句话说，它不应该是一个新行，我们可以使用“r-string”告诉 Python 不要解释它。
print(r'a\nb')
当我们编写正则表达式模式时，有时我们必须使用斜杠或其他特殊字符。因此，为了避免 Python 解释器以错误的方式解释字符串。在定义正则表达式模式时，总是建议使用“r-string”。
假设我们正在搜索一个模式，其中几个字母在几个空格后重复，我们可以如下编写正则表达式。
re.search(r'(\w+)\s+\1', 'abc abc')
然而，如果我们在这里不使用“r-string”,“组”指示器\1将不会被识别。
2.使用 re。必要时忽略大小写标志
“标志”在 Python Regex 中是独一无二的，不是所有其他编程语言都有的。即，创建不区分大小写的正则表达式模式。
假设我们想匹配一系列字母，不管是大写还是小写。当然，我们可以这样写。
re.search(r'[a-zA-Z]+', 'AbCdEfG')
这绝对是标准的方式，如果我们不加A-Z，就不会像预期的那样匹配整个字符串。
然而，Python 提供了这样一种方式，我们可以更专注于模式本身，而不需要担心字母的大小写。那就是用re.IGNORECASE。你甚至可以把它做得很短，就像re.I做的一样。
re.search(r'[a-z]+', 'AbCdEfG', re.IGNORECASE)
re.search(r'[a-z]+', 'AbCdEfG', re.I)
3.使用 re。用于提高可读性的详细标志
正则表达式的一个主要缺点是可读性差。通常，这是我们必须面对的问题。但是，您知道 Python 有更好的方法来提高正则表达式模式字符串的可读性吗？那就是使用re.VERBOSE标志。
我们可以在第 1 节重写 regex 模式。最初，模式字符串必须是r'(\w+)\s+\1'。嗯，这还不算太糟，但是假设我们有一个复杂得多的模式，大概只有作者能理解。这是 regex 的一个常见问题。然而，对于 verbose 标志，我们可以这样写。
re.search(r'''
(\w+) # Group 1: Match one or more letters, numbers or underscore
\s+ # Match one or more whitespaces
\1 # Match the Group 1 whatever it is
''', 'abc abc', re.VERBOSE)
完全等同于r'(\w+)\s+\1'。请注意，如果我们要这样写的话，标志re.VERBOSE是必备的东西。否则，正则表达式当然不会工作。
同样，该标志有一个简短的版本— re.X。
4.定制 re()的替换行为
re.sub()是 Python regex 中最常用的函数之一。它试图在一个字符串(string)中找到一个模式(pattern)，并用提供的替换字符串(repl)替换它。
re.sub()是 Python regex 中最常用的函数之一。它
re.sub(模式，复制，字符串，计数=0，标志=0)
例如，下面的代码将隐藏字符串中的任何手机号码。
re.sub(r'\d', '*', 'User\'s mobile number is 1234567890')
大多数开发人员都知道这个函数。然而，很少有人知道我们实际上可以为repl参数使用一个函数。
例如，我们仍然希望隐藏用户的电话号码，但是我们希望显示最后 3 位数字，以确保用户知道那个号码是什么。我们可以先定义下面的函数。
def hide_reserve_3(s):
return '*' * (len(s[0])-3) + s[0][-3:]
在这个函数中，它将一个 Python 正则表达式匹配对象(s)作为唯一的参数。如果有多个匹配，对象s将包含多个字符串，所以我们需要循环它。但是为了演示的目的，让我们在例子中简单一些。s[0]将是第一个匹配的电话号码。
然后，我们返回的是重复几次的星号。也就是说，如果字符串的长度是 10，那么将返回 10–3 = 7 个星号。然后，尾部的 3 位数字会保持原样，所以会显示出来。
当然，lambda 函数也可以。如果定制的函数不太复杂，使用 lambda 函数也可以。
re.sub(r'\d+', lambda s: '*' * (len(s[0])-3) + s[0][-3:], 'User\'s mobile number is 1234567890')
5.使用 re.compile()实现可重用性
照片由 Shirley810 在 Pixabay 上拍摄
有时我们可能想要多次使用一个模式。很可能一个可重用的 r 字符串变量就足够了。然而，如果我们想将模式用于不同的目的，以及想提高可读性，使用re.compile()可能是一个更好的选择。
pattern = re.compile('abc')
用re.compile()定义图案后，我们可以根据需要多次使用它。
6.使用正则表达式生成字典
有时我们希望使用 regex 从遵循相同模式的字符串中提取信息。然后，把它们放进字典是一个很好的主意。例如，字符串"My name is Christopher Tao and I like Python."包含一个人的名字、姓氏和首选语言。如果我们有很多这样的字符串，并希望将信息提取到字典中，我们实际上可以在没有任何开销的情况下做到这一点。Python 正则表达式可以实现开箱即用。
re.match(
r"My name is (?P<first_name>\w+) (?P<last_name>\w+) and I like (?P<preference>\w+).",
"My name is Christopher Tao and I like Python."
).groupdict()
在 regex 模式中，我们可以定义匹配字符串的“键”，然后它们会被自动映射到一个字典中。
我们必须遵循模式(?P<Y>...)，其中Y是键名，...是定义的正则表达式模式。
7.使用正则表达式组捕捉重复模式
照片由 Pixabay 上的 StockSnap 拍摄
我们都知道正则表达式可以捕捉模式。然而，有时我们想以一种更“高级”的方式来捕捉模式。例如，我们不知道一个模式将匹配什么样的字符串，但是如果它重复多次，我们希望捕捉整个字符串。
事实上，我们在第 1 节和第 3 节中使用的例子正好实现了这一点。让我再举一个例子。也就是说，我们想找出是否有一个字母在字符串中重复出现。如果有，是什么？
pair = re.compile(r'''
.* # Match any number of any charaters
(.) # Match 1 character, whatever it is (except new-line), this will be the "group 1"
.* # Match any number of any charaters
\1 # Match the group 1
''', re.VERBOSE)pair.match('abcdefgc').groups()[0]
我们需要首先定义模式。在这里，我使用了re.VERBOSE标志，这样更容易阅读和理解。在模式中，我们用圆括号定义一个“组”，然后用这个“组”后面的\1来捕捉“重复的”字符串。
最后，我们使用编译后的正则表达式模式并尝试匹配字符串。然后，获取匹配组的第一个元素。这将是在字符串中发现的第一个重复的字母。
摘要
图片由 liming0759 在 Pixabay 上拍摄
在这篇文章中，我整理了 7 个小技巧，我认为对一些学习者有用，如果你从来没有以这种方式使用正则表达式，也可以补充你的知识。
让我们一起编写可读性更好、更方便的 Python 正则表达式。
https://medium.com/@qiuyujx/membership
如果你觉得我的文章有帮助，请考虑加入 Medium 会员来支持我和成千上万的其他作者！(点击上面的链接)
每个开发人员都需要知道的 7 个 VS 代码技巧
学会充分利用你的 IDE，并确保利用它的全部力量来加速你的开发。
多年来，我一直使用 VS Code 作为我的主要 IDE。虽然说实话，我花了几年时间才开始使用它。在我作为开发人员的早期，我只是简单地利用了 VS 代码中的默认值、语法高亮、代码建议等等。然后在我更新了一天之后，终于花时间看了一下入门。我希望我以前就这样做了，原因如下。
代码片段—干存储和示例存储
代码片段是代码的模板，你可以在不同的项目中重复使用。您创建经常重复的代码，并使它们作为代码建议出现。如果你经常创建一个循环来迭代数组，那么你可以为它创建一个代码片段，这样你就再也不用输入它了。您可以为本地项目、所有项目的全局项目以及某些编程语言创建代码段。你也可以在 VS 代码中找到市场上的代码片段。
我使用片段来避免一遍又一遍地重复常见的模式，也帮助我记住如何做事情。当你编码的时候开始构建你的库，你会感谢我的。
在扩展中搜索@category:"snippets"将只搜索片段，您也可以在之后指定某些关键字。这就是我如何搜索 Go 特定片段的方法@category:"snippets" go
我发现创建我的片段是最有效的方式。你可以很容易地创建一个。进入顶部的菜单，进入File->Preferences->User Snippets。选择要创建的本地或全局代码段，然后命名。我将我的代码片段命名为go-snippets,因为它将包含我所有与 Go 相关的代码片段，并将在全球范围内使用。
让我们从一个超级简单的例子开始，在 Go 中你经常写下面的语句来查看是否有错误发生。
if err != nil {
return err
}
我们可以创建一个片段，这样我们就再也不用写了。在生成的 go-snippets 文件中输入以下内容。
片段中使用的一些值是
- 范围 —启用代码片段的所有语言的逗号分隔列表。在这种情况下，我只使用
go - 前缀 —代码片段的名称
- 正文 —要生成的代码行，我们甚至可以在这里输入参数，我们将在示例 2 中看到
- 描述 —显示在代码完成选项卡中的文本描述
在 Go 中生成错误检查的 VS 代码片段
插入之后，保存代码片段文件，如果你打开任何一个.go文件并输入Err，你会看到代码片段是一个建议。
展示了 VS 代码中的错误检查片段如何生成一个 nil 签入 Go
这个例子很简单，您甚至可以为更高级的代码片段输入参数。
我在我的项目中使用了很多依赖注入，并且我通常有一个保存所有存储库的Service结构。在所有项目中，这个服务的创建都是一样的，我总是重新键入它，我总是忘记如何重新键入。结果就是我总是浪费几分钟的时间去调出一个老项目，看看我做了什么。
让我们来看看如何为此创建一个代码片段。看我如何在正文中添加$1，这就是你如何添加输入值，如果你需要更多的值，然后在数字上加+1，$2，等等。
生成类型、函数和构造函数的 NewService 代码段
我如何使用代码片段在几秒钟内生成构造函数、类型和别名函数的例子
看到所有的代码了吗？它生成的速度有多快？片段可能是我最喜欢的 VS 代码特性。我倾向于不仅使用它来存储公共代码片段，还将其作为如何执行特定算法的内存集合。它节省了我的时间、金钱和挫败感。
日志点——永远不要再用未忘记的打印记录填充日志
您必须记住将调试打印输出到终端的日子已经过去了。
是的，我有罪，我确实使用调试器，但是有时候打印某个值，或者一个简单的IM HERE在调试时是非常有效和容易的。很多时候，我们忘记删除这些调试打印，对不对？
- 表达式—仅在特定表达式为真时记录
- 命中计数—当满足命中计数条件时中断，适用于循环或长时间运行的服务，在这些服务中，错误在 X 运行后开始出现。
- 记录消息—始终记录消息
遗憾的是，Logpoints 并不支持所有语言(呜呼，由于一个问题，我不喜欢 Go)你可以在这里找到所有支持的语言。在下面的 GIF 中，你可以看到我如何在 python 中设置一个 logpoint 来打印函数调用的返回结果。表达式放在{}内。
在 Python 中设置一个日志点，并看到它打印函数的输出
选择并重命名(Select+F2)-平滑重命名
我讨厌在 VS 代码中重命名变量和函数。为什么？我曾经使用 VS 代码基本编辑指南中关于如何找到并替换的建议方法来执行函数的重命名等。我从来不喜欢 VS 代码中的 find UI。
想象一下当我得知F2是一个重命名命令时我有多惊讶。它甚至适用于整个项目。只需选择您想要更改的单词，然后按下F2键，然后输入新的正确单词。
看看我能多快地将代码片段中的Service改为TestService。这也为我节省了很多时间，我希望我以前就知道。
在多个文件中重命名出现的单词，简单的查找和替换
注意注释没有改变，只有代码实例。VS 代码基本编辑教程中的查找和替换建议支持但不支持的一点是，您可以检查每个替换并接受它们。根据我的经验，F2在寻找合适的作品方面做得天衣无缝。
多光标选择(ALT+单击)(键盘上的 Shift+ALT+向上/向下)
VS 代码有一个叫做多光标选择的东西。这意味着我们可以同时有多个光标出现。
你可以同时在两个地方写作，所以使用第二个键盘，加倍编码，加倍你的速度！
好吧，打住，那是个玩笑。遗憾的是我们只能使用一个键盘，但是我们可以同时编辑很多地方。
按住alt并点击您想要编辑的位置，您将在所有标记的光标处打字。
按住 ALT 键在 VS 代码中创建多个光标
现在这个特性本身从来没有打动过我，我很难找到用例。那我为什么把它带进列表？
简单！这种多光标允许结合使用其他命令，以获得强大的功能。清单上的下一项将展示这一点。
选择一个单词的所有匹配项(Select + (CTRL+SHIFT+L))
这是另一个重构技巧。注意到F2替换只对代码实例起作用了吗？
有时候我们想改变注释，或者简单的文本文件等等。很高兴您最近学习了 Vs 代码中的多光标选择。我们可以把多光标和选择单词结合起来。
选择您想要修改的单词，然后按下ctrl+shift+L，VS 代码将在每个实例上生成一个光标。这可以用来改变一个变量的名字，例如，甚至在注释和更多。
展示了如何在一个选中的单词上产生多个光标并替换所有出现的单词
在文件中定位(CTRL+Shift+O)
由于某种未知的原因，VS 代码中的 outline 函数默认是折叠的。这是一个非常好的功能，我喜欢打开它。
大纲是文件中代码的可视化。不用滚动浏览整个文件就能快速了解文件中的内容是很好的。
VS 代码中的大纲显示了代码的结构。
使用ctrl+shift+o我们可以在这些概述的项目之间跳转。这对于在大型代码库或文件中快速导航很有用。
按下快捷命令将打开一个搜索提示，您可以使用它来搜索所需的功能、结构，更多取决于所选择的语言。
为了更方便，你可以在搜索中的@后添加:，按类别分组。这使得查看文件中的代码结构更加容易。我倾向于在新的代码库中经常使用这个来了解文件中的内容，而不是盲目地滚动。
VS 代码大纲跳转——导航代码时节省时间
按住 ALT 键快速滚动
这个技巧不需要大的解释，它只是一个小特性，一旦我学会了它，我就想起了过去我需要它的所有时间。
按住ALT键并滚动，尝试不按住滚动，当按住时，速度差异很大，在巨大的文件中非常非常方便。
这是我在 VS 代码中最常用的七个特性，我希望你喜欢，并希望学到一些新东西。
感谢您的阅读，并随时以任何可能的方式联系我，在这里发表评论，在 twitter 、 Linkedin 上。
VS 代码中你最擅长的特性是什么？你觉得我错过了给任何东西爱吗？
https://percybolmer.medium.com/membership
实验打破的 7 种方式
开始实验时要避免的常见错误
开始实验有点像开始认证。这并不难，而且你有一种感觉，你会弄明白的。但是就像鉴定一样，实验中的错误可能代价高昂。以下是实验中需要注意的一些常见错误。
1。在错误的地方设置作业
设计实验的一个常见错误是过早地布置任务。理想情况下，您希望在需要渲染体验的时候设置分配。过早设定任务会导致更中立或不确定的实验。例如，10 个访问者登陆了你的产品页面，这 10 个访问者中有 1 个会从产品页面转到定价页面。如果你在定价页面上做一个实验，那么当访问者到达定价页面时，而不是当他们到达产品页面时，进行分配。
2。缺少仪器
你有没有听到自己说，'我确定这个动作是被跟踪的'，然后开始实验后才意识到其实不是？我也是！这意味着我必须回去，添加仪器，并重新开始实验。我分配给这个实验的 14 天中有两天过去了。当您测试您的仪器时，检查丢失的事件和事件中丢失的数据(特别是单元标识符)。
3。实验动力不足
统计功效是检测到真实效果的概率。当一个实验的功率很低时，很难找到真正的效果。这可能会导致统计学上的显著结果，即假阳性而非真实效果。为了确保实验有足够的动力，有耐心让实验运行并达到所需的样本量！
4。被困在当下
低功率实验也可能高估效果的强度(假设这是真实的效果)。正如 Pinterest 发现的那样，这可能会导致参与偏差，即参与用户首先出现并主导实验结果。"如果你相信短期结果，而不考虑并试图减轻这种偏见，你就有被困在现在的风险:为你已经激活的用户而不是你想在未来激活的用户开发产品。“为了避免陷入投入偏差，在不同阶段为用户尝试不同的实验。
5。限制你的范围
刚开始做实验的人经常把实验主要与公司的“增长”功能联系在一起，该功能专注于注册新用户。扩大你的范围，让更多的用户了解你的应用的核心价值，可以为实验打开更多的空间。例如，网飞发现在观众放弃服务之前有 90 秒的时间，这使得个性化实验对他们的参与度和保持度非常有价值。[ 问题:你知道新用户在你的应用中体验快乐的时刻吗？ ]
6。没有计划的实验
大量的网站优化工作集中在改变按钮颜色和移动泰坦尼克号周围的椅子。往墙上扔东西看看粘了什么不是计划。将你的实验和你的产品策略联系起来。例如，如果您知道延迟对您的产品参与非常重要，但不知道重要到什么程度，请测试您的假设，并让数据定义您的产品策略。例如，脸书了解到，信息传递越快，参与度就越大。利用这些数据，他们重新构建了Messenger 应用程序，启动速度提高了一倍，专注于核心功能，并通过项目光速剥离了其余功能。
7。关注小创意
虽然不像没有计划的实验那么糟糕，但一个相关的陷阱是专注于导致小结果的小调整。对微小改进的测试也往往需要更大的样本量才能具有统计显著性。关注低挂果和高冲击的交集。随着组织中越来越多的人意识到增量实验的成本接近于零，他们自然会想把每个特性都变成 A/B 测试，就像 Booking.com 的优步和 T15 一样。
缓解措施总结
概括地说，有两种类型的减轻实验中的错误。
- 从战术上来说，你要在合适的点上分配用户，仪器每个用户的动作，并让实验运行。
- 从战略上来说，你希望为不同的群体进行实验，确定应用程序中的快乐时刻，将实验与战略目标联系起来，寻找产生更大影响的机会，并鼓励快速、无处不在的实验。
如果你看到了从没有计划->有策略->测试每个特性的旅程，你已经远远领先于大多数人了👀
加入 Statsig Slack channel 讨论您的实验并获得帮助。无论您是否在 Statsig 上运行，我们都希望看到您的实验成功！
奖金
你会问，如果没有一些额外的功能，它怎么可能是一个真正的列表呢？
好吧，这里有一些摩尔错误……
- 目光短浅:在试验的早期，你可能会听到团队成员说，你只关注数据或你只关注一组指标。实验不仅仅是获取数据来做决定，而是形成完整的画面。将实验结果与其他定量和定性数据结合起来，形成你的商业图景。
- 错过学习:无论一项实验能否产生统计结果，它都是产生新的假设和见解的沃土。在这个例子中，Roblox 想要确定他们的化身商店对社区参与度的因果影响，并在他们一年前进行的实验中找到了他们丢失的部分！
- 耗尽不可测量的资源:您可以使用护栏指标避免无意中耗尽宝贵的资源。假设您发现了新的推送通知渠道，它在提高参与度方面显示出了巨大的成效。然而，如果你过度使用它，你会用过多的通知烧坏频道。您可以为推送通知设置一个防护栏阈值，以便在提升频道之前达到 8%+点击率。如果你的实验缺少护栏指标，问问你自己:我缺少什么权衡？ 我如何将这种权衡建模为护栏指标？
[1]借助合适的实验平台，您可以运行数千次实验，而不必担心管理数据管道的繁重工作或每天处理大量数据的基础设施成本。理想的实验平台还将确保这数以千计的实验被组织起来，以便在不影响彼此的结果的情况下相互清除。
将外部数据加载到 Google Colab 的 7 种方法
改善您的 Google Colab 体验的提示和技巧
照片由 Ehimetalor Akhere Unuabona 在 Unsplash 上拍摄
Colab (简称 Colaboratory )是谷歌的一个免费平台，允许用户用 Python 编码。Colab 本质上是谷歌版的 Jupyter 笔记本。与 Jupyter 相比，Colab 的一些优势包括零配置、免费访问 GPU&CPU 以及无缝共享代码。
越来越多的人使用 Colab 来利用高端计算资源，而不受其价格的限制。加载数据是任何数据科学项目的第一步。通常，将数据加载到 Colab 需要一些额外的设置或编码。在本文中，您将了解到将外部数据加载到 Google Colab 的 7 种常用方法。这篇文章的结构如下:
- 通过文件浏览器上传文件
- 使用
files模块上传文件 - 从 Github 读取文件
- 克隆 Github 存储库
- 使用 Linux
wget命令下载文件 - 通过在本地安装来访问 Google Drive
- 加载 Kaggle 数据集
1.通过文件浏览器上传文件
您可以使用文件浏览器顶部的上传选项将任何文件从本地机器上传到 Google Colab。
你需要做的是:
步骤 1: 点击文件图标，打开“文件浏览器”窗格
单击文件图标(按作者排列的图像)
步骤 2: 点击上传图标，从“文件上传”对话框中选择您想要上传的文件。
(图片由作者提供)
步骤 3: 上传完成后，您就可以像平常一样读取文件了。例如，pd.read_csv('Salary_Data.csv')
(图片由作者提供)
2.使用 Colab files模块上传文件
除了点击 GUI，您还可以使用 Python 代码来上传文件。您可以从google.colab导入files模块。然后调用upload()启动“文件上传”对话框，选择您想要上传的文件。
from google.colab import files
uploaded = files.upload()
文件上传对话框
上传完成后，您的文件应该会出现在“文件资源管理器”中，您可以像平常一样读取文件。
(图片由作者提供)
3.从 Github 读取文件
读取数据最简单的方法之一是通过 Github。点击 Github 存储库中的数据集，然后点击“ Raw 按钮。
(图片由作者提供)
复制原始数据链接，并将其传递给可以接受 URL 的函数。例如，将一个原始的 CSV URL 传递给 Pandas read_csv():
import pandas as pddf = pd.read_csv('[https://raw.githubusercontent.com/BindiChen/machine-learning/master/data-analysis/001-pandad-pipe-function/data/train.csv](https://raw.githubusercontent.com/BindiChen/machine-learning/master/data-analysis/001-pandad-pipe-function/data/train.csv)')
4.克隆 Github 存储库
您还可以使用git clone将 Github 存储库克隆到您的 Colab 环境中，就像在您的本地机器中一样。
!git clone [https://github.com/BindiChen/machine-learning.git](https://github.com/BindiChen/machine-learning.git)
一旦存储库被克隆，您应该能够在“文件资源管理器”中看到它的内容，并且您可以像平常一样简单地读取文件。
git 克隆并读取 Colab 中的文件(图片来自作者)
5.使用 Linux 的wget命令从网上下载文件
既然 Google Colab 允许你在本地托管的 Jupyter 笔记本上做任何你能做的事情，你也可以使用 Linux shell 命令，比如使用!的ls、dir、pwd、cd等。
在这些可用的 Linux 命令中，wget允许你使用 HTTP 、 HTTPS 和 FTP 协议下载文件。
最简单的形式是，当不使用任何选项时，wget会将 URL 中指定的资源下载到当前目录，例如:
wget in Colab(图片由作者提供)
重命名文件
有时，您可能希望以不同的名称保存下载的文件。为此，只需传递-O选项，后跟新名称:
!wget https://example.com/cats_and_dogs_filtered.zip \
**-O new_cats_and_dogs_filtered.zip**
将文件保存到特定位置
默认情况下，wget会将文件保存在当前工作目录下。要将文件保存到特定位置，使用-P选项:
!wget https://example.com/cats_and_dogs_filtered.zip \
**-P /tmp/**
无效的 HTTPS SSL 证书
如果您想通过 HTTPS 从拥有无效 SSL 证书的主机下载文件，您可以通过--no-check-certificate选项:
!wget https://example.com/cats_and_dogs_filtered.zip \
**--no-check-certificate**
一次多个文件
如果您想一次下载多个文件，请使用-i选项，后跟包含要下载的 URL 列表的文件路径。每个网址需要在一个单独的行。
!wget **-i dataset-urls.txt**
下面是一个展示 dataset-urls.txt 的例子:
http://example-1.com/dataset.zip
https://example-2.com/train.csv
http://example-3.com/test.csv
6.通过在本地安装来访问 Google Drive
您可以使用google.colab中的drive模块将您的 Google Drive 安装到 Colab。
from google.colab import drive**drive.mount('/content/drive')**
执行上述语句时，您将获得一个身份验证链接和一个文本框来输入您的授权码。
单击身份验证链接，并按照步骤生成您的授权码。复制显示的代码，并将其粘贴到文本框中，如上所示。一旦装载完毕，您应该会收到如下消息:
Mounted at /content/drive
之后，您应该能够通过“文件资源管理器”浏览内容，并像平常一样读取数据。
最后，要卸载您的 Google Drive:
drive.flush_and_unmount()
7.加载 Kaggle 数据集
可以从 Kaggle 无缝下载任何数据集到你的 Google Colab。你需要做的是:
步骤 1: 下载您的 Kaggle API 令牌:转到 Account 并向下滚动到 API 部分。
生成 Kaggle API 令牌(图片由作者提供)
通过点击“创建新的 API 令牌”，一个 kaggle.json 文件将被生成并下载到您的本地机器。
第二步:上传 kaggle.json 到你的 Colab 项目:比如你可以从google.colab导入files模块，调用upload()启动文件上传对话框，从本地机器选择 kaggle.json。
上传 kaggle.json(图片由作者提供)
第三步:更新KAGGLE_CONFIG_DIR路径到当前工作目录。您可以运行!pwd来获取当前工作目录，并将值赋给os.environ['KAGGLE_CONFIG_DIR']:
配置 KAGGLE_CONFIG_DIR(图片由作者提供)
步骤 4: 最后，您应该能够运行以下 Kaggle API 来下载数据集:
!kaggle competitions download -c titanic!kaggle datasets download -d alexanderbader/forbes-billionaires-2021-30
下载 Kaggle 数据集(作者图片)
注意:对于竞争数据集，Kaggle API 应该在数据选项卡下可用
从竞赛数据集中检索 Kaggle API(图片由作者提供)
对于通用数据集，可以按如下方式访问 Kaggle API:
从通用数据集中检索 Kaggle API(图片由作者提供)
结论
对于那些希望利用高端计算资源(如 GPU、TPU)的能力而不受价格限制的个人来说，Google Colab 是一个很好的工具。
在本文中，我们已经介绍了通过将外部数据加载到 Google Colab 来改善您的 Google Colab 体验的大多数方法。希望这篇文章能帮助你节省学习 Colab 和数据分析的时间。
感谢阅读。如果你对机器学习的实用方面感兴趣，请继续关注。
你可能会对我的一些熊猫文章感兴趣:
- 熊猫将数字和字符串转换成日期时间的 10 招
- 使用熊猫方法链接提高代码可读性
- 如何对熊猫数据帧进行自定义排序
- 数据分析你应该知道的所有熊猫移位()
- 何时使用 Pandas transform()函数
- 你应该知道的熊猫串联()招数
- Pandas 中 apply()和 transform()的区别
- 所有熊猫合并()你应该知道
- 在 Pandas 数据帧中处理日期时间
- 熊猫阅读 _csv()你应该知道的招数
- 用 Pandas read_csv()解析日期列应该知道的 4 个技巧
更多教程可以在我的 Github 上找到
作为数据科学家保持最新状态的 7 种方法
关于人工智能最新进展的可行建议
数据科学:一个不断进化的世界
在 2021 年成为一名数据科学家通常意味着每天至少要用 Python 工作 4 到 5 个小时。但这已经是 2021 年了。未来十年将会发生什么？没人知道。
如果核心数据语言保持相当稳定，不会在一夜之间发生变化，那么没有一周没有新的改变游戏规则的 ML 论文、数据公司的融资或著名 Python 库的新版本。我们周围的世界——数据科学家——每天都在进化。在这样的背景下，保持与时俱进并了解最新趋势成为一项艰巨的任务。
意识
当我刚毕业的时候，我没有意识到继续学习和发现新的视角对我的工作发展有多么重要。3 年前，在我人生中的第一次面试中，我坐在巴黎一家初创公司的首席技术官前面。一切都进行得很顺利，直到那个人问我:“你是如何进行科学文献综述的？”。就在那一刻，我意识到我没有答案，甚至不知道什么是好的答案。即使我知道这显然还不够，我还是发了一些 LinkedIn 群组和面向技术的新闻。从那一刻起，我真的开始注意这一点，并意识到保持自己在页面的前端是多么重要。
保持关注的七种方式
1.中号和口袋型
如果你正在读这篇文章，很可能你已经在使用 Medium 了，不需要说服你！但是你有效地利用它了吗？还是你只是在看建议列表里的帖子？
我发现一个很好的方法就是选择一个你想深入研究的领域，然后花两三周的时间，积极寻找相关的帖子。它可以是 MLOps、AWS、干净代码、地理数据、熊猫专题、CNN 或者任何你感兴趣的东西。
除了 Medium 之外， Pocket 应用程序还允许你保存故事，以便日后查阅，即使你无法访问互联网。
建议套路:一旦你找到了本月的主题，每晚睡前找 5 篇文章。把它们登记在口袋里。然后当你在交通工具上或者有空闲时间的时候，读读它们，而不是去 Instagram！
2.YouTube 和播客
如果你能在 YouTube 上找到数量惊人的蠢事，那也是一座知识的金矿！有很多非常有趣的科学频道。既有技术性的也有低俗化的。根据你的兴趣点订阅一些是发现新概念的好方法。
我个人非常喜欢两分钟的论文。每隔几天就会发布一个新的视频。它们是关于新人工智能论文的简短而有趣的视频。这很好，因为不需要太多的时间。为了保持一致，我订阅了这个频道，并且从不拒绝他们的任何通知。我要么观看视频，要么将新的视频通知保存在我的手机通知中，直到我观看它。
建议套路:找一个高频短视频的日频道(用于对科学概念的涵化)和低频较长视频的周频道(用于深度技术内容)。视频一出来就看。
3.MeetUps (&网络研讨会)
去 Meetup s 有点像 YouTube 视频的现场版。但远不止如此。当你去聚会的时候，你和真实的人交谈。除了聆听专家的精彩内容，您还有机会见到他们。如果你像我一样很内向，一开始可能会有点可怕，但是外面的人和你有着相同的热情。他们中的一些人会过来和你谈话。保证良好的体验！
由于新冠肺炎疫情，组织和参加聚会变得更加困难。但是你会发现很多在线研讨会，专家们正等着你的问题。很快，当我们回到 covid 后的现实生活时，在接下来的 12 个月里尝试每月一次聚会可能是一个不错的决定！
建议常规:在 MeetUp 应用上找出那些在你家附近举办活动的团体(如今许多城市都有 NLP 或 CV 团体，也许你所在的城市也有！)，然后明确自己的志向。每个月尝试一次是可行的。
4.读书
我认为，阅读书籍是理解深入概念或技术的最佳方式。很长一段时间，我认为阅读技术书籍是一个老人的概念。“今天，你可以在互联网上几乎免费地获取所有知识。何必为一本书费心？”我在想。直到我读了一本。并且意识到作者是如何通过这本书给出自己的观点，而不是在网上陪你看一堆教程。要发现一门语言的深层概念，读一本关于这门语言的书可能会为你赢得宝贵的时间。
建议套路:“套路”在这里不是一个好词，比如读一本技术书需要时间和专注，从而不是一件作为目标周期性去做的事情。当你想发现一门语言或一个科学领域(React，Python，Deep Learning，…)时，在获得一些互联网知识和实践后，我最好建议你读一本。
5.文件和代码
对于包括我在内的许多人来说，阅读科学论文是一种骚扰。当然可以时不时的看一些，有个固定的目标！开始时，这很难，也很费时间，但是随着习惯的养成，你会越来越快地阅读和理解它们。例如，你可以从历史性的论文开始，如 ImageNet 分类与深度 CNN 或你只看一次:统一，实时物体检测
但是，处理一篇论文比阅读它更有趣的事情是实施它💻paperswithcode.com 在这里帮你解决这个问题！这绝对是理解迷人的机器学习算法的基本概念的好方法。
建议常规:当你觉得喜欢并且还有一大堆时间的时候，浏览一下网站。选择一个你觉得好听的 ML 类别。选择一篇论文，使用你知道的图书馆(或者想要发现的图书馆，这取决于你的精神状态😉)去争取吧！
6.开源代码库
你可能已经看过它上千次，但从未点击过它:GitHub 是一个“探索”标签，它总结了平台上一天的大事。你将有机会看到著名项目的更新或成长中项目的崛起。通过主题过滤，你可以选择“机器学习”、“深度学习”或任何你喜欢的框架/公司。
建议套路:我从来没有真正做过，但我认识一些同事，他们总是在 GitHub explore 及其主题上花几分钟开始一天的工作。
7.LinkedIn 和 Twitter
最后，关注 Twitter 或 LinkedIn influent 上你喜欢的领域的人或订阅专门的群组，会让你与他们和他们分享的概念保持联系。这是发现新事物的好方法，也是你进一步调查的好开端。
建议常规:每天花一些时间在那些上面，但不要太多。这是一个让自己跟上时代的实用方法，但是大多数时候你只能找到基本的信息。对于你的文献综述，更喜欢优质内容！
结论
数据科学是一个每天都在发展的领域，需要不断学习。网上有很多资源可以帮助你开始持续学习，今天我们讨论了一些跟上时代的策略。我给你建议了一些套路，你可以根据自己喜欢的学习方式调整其中的任何一个。现在，我想引用威廉·亚瑟·沃德的一句话来结束我的演讲，他说**好奇心是学习之烛的灯芯。我完全同意这个观点，所以我只能鼓励你去好奇。对我来说，好奇和热爱学习几乎是成为一名优秀数据科学家的一半工作。
希望你喜欢&回头见🤠！
让你的视觉化更上一层楼的 7 种方法
更好的可视化有助于证明你的努力
如果你读过我的一些其他文章，你一定已经注意到我倾向于重复几个句子，比如“数据科学就是关于数据的”，或者“没有数据你就不能拼写数据科学”，或者我个人最喜欢的“作为一名数据科学家，你只是试图传递你的数据的故事。”
在我看来，数据科学家是一种特殊类型的讲故事者。他们得到一个数据集，通常是杂乱和无结构的，然后他们需要提炼这个数据集，找到它的模式和趋势，并帮助传递它所讲述的故事。然后，这个故事被用来帮助做出更好的商业决策，并帮助增强用户的服务或产品。
但是，讲故事是一项不同于数据科学家所需的其他技能的技能。它利用你的创造力、设计技巧和能力，以最简单、最有效的方式解释和传递信息。尽管一开始提高这一技能似乎很有挑战性，但是一旦你了解了高效可视化的基础，你就可以很快提高你的技能。
如果您想要创建有效的可视化，以最好地帮助传递您的数据故事，那么您需要注意一些特定的信息。一旦你考虑了这些部分，你将创造出美丽、高效、简单的可视化效果，任何人都可以理解，并证明你为寻找隐藏的故事所付出的努力。
№1:为您的数据选择最佳图表类型
更好的可视化的第一步是了解您的数据并确定哪个图表最适合它。有各种类型的图表和图形，每一种都是为描述特定形式的数据而设计和创建的。例如，如果您要比较同一类别中的几个数据值，如特定时间段内两家或更多公司的汽车销售，条形图是一个不错的选择。
折线图用于显示一段时间内的数字趋势。散点图用于显示变量之间的关系。直方图显示数据在一段时间内的分布，饼图显示数据点在一个类别中的比例分布。
因此，通过了解每个图表的用途，您将能够使用一个图表来增强您的数据故事，并有助于最好地交付它。当谈到图表时，你不应该害怕组合不同的类型或尝试新的类型来帮助你更好地表达你的故事。
№2:保持简单
简单永远是最好的策略。我知道，有时我们倾向于选择复杂的可视化，因为如果它看起来复杂，它会传达我们努力分析和构建可视化的感觉，但事实并非如此。如果你完全理解了某事，那么你就能解释它。
选择简单的图表；如果在同一个可视化中有多种类型，请确保以易于理解的方式组织它们。你的工作越容易被理解，别人对它的感知就越好。
№3:额外注意你的可视化文本
我知道一张图片抵得上 1000 个字，但是我们无法创建一个完全没有文字的可视化。我们也不能用多余的文本来填充我们的可视化，这将剥夺它的价值，并使它看起来混乱。所以，一旦你决定了使用什么图形和图表，你需要花些时间来决定所有与文本相关的东西。
创建可视化时，通常会包含三种类型的文本、标题、级别和图例。一个可视化的标题需要是描述性的、精确的、切中要点的。你的观众应该通过阅读标题而不需要任何额外的信息来理解可视化所呈现的内容。
下一步，标签，确保你的标签清晰，有一个可读的大小和简单的字体，不要忘了标签你的轴。图例应该被明智地使用，并且应该使理解你的图表更容易。对于所有这些文本，你需要使用简单的短语，除非必要，避免注释，避免花哨的分散注意力的字体，避免重复你的信息。
№4:利用你的颜色
接下来，颜色。让我们挖掘自己的创造性和艺术性——相信我，每个人都有。颜色是改变你形象的强大工具。你可以选择正确的图表，使用简单有效的文本，但使用错误的颜色来突出你的故事，导致你的视觉效果最终令人困惑和误导。
所以，利用色彩理论是你开始创造更好的视觉效果的第一步。在处理颜色时，请确保对同类数据使用相同的颜色，如果您想将文本与图形的特定部分相匹配，请确保对两者使用相同的颜色。避免使用太多的颜色，因为它们会让人混淆。
您还可以利用阴影、色调和色温来帮助区分数据强度。如果你需要帮助决定颜色或考虑搭配口味，你可以使用像颜色帮助和酷派这样的工具。
№5:更多地使用动态可视化，而不是静态
当我们处理数据时，我们经常需要将数据随时间可视化，并且我们需要比较数据的不同实例。您需要考虑的一种方法是使用交互式可视化，您可以删除一些数据类别，以便更好地理解图表。
另一种选择是在不同的时间间隔或不同的条件下创建相同基础图的 Gif，以突出数据中的变化。这种策略也可以作为演示的一部分，这样你就可以带着你的观众一步一步地经历这些变化。
№6:永远记住你的观众
有些人可能会把了解你的观众作为创造更好的视觉效果的第一步，但是我决定不这样做是有原因的。如果你创建了良好的可视化，它应该很容易被不同背景的人理解。这类似于用户体验设计；通常，公司在设计他们的界面时会试图满足最大的人群。
也就是说，一般化并不总是最好的选择。有时，您需要为特定的受众创建可视化效果。例如，如果您在一家公司工作，他们可能对您需要创建的可视化有特定的要求。在这种情况下，您需要遵循这些规则，同时使您的数据易于理解。
№7:从数据可视化设计者那里获得灵感
数据可视化是一种艺术形式，学习和提高讲故事能力的一些最佳方式是研究他人的作品并从中获得灵感。数据可视化设计领域有很多伟大的艺术家，他们花费时间来创建令人惊叹的可视化效果，您可以用它来获得灵感或收集想法。如果你需要灵感，这个列表是一个很好的起点。
外卖食品
有时候当我看其他数据科学家和数据可视化设计师的工作时，我觉得他们是艺术家而不是数据科学家。他们选择图表、颜色和字体的方式让我渴望成为一名更好的数据科学家和更高效的故事讲述者。
</4-data-visualization-tools-to-transform-your-data-storytelling-e2c6fb6de8ba>
我提高数据可视化技能的旅程不仅仅是为了成为一名更好的数据科学家。看，提高你的视觉化技能意味着如果你在学术界，你会成为一个更好的演讲者，一个更好的演讲者，一个更好的研究者。我们都有过糟糕的数据可视化的经历，我们都曾想过，“如果图表类型是…”，这可能会更有效率。
但是，就像任何其他技能一样，提高你的讲故事和视觉化需要练习、时间和一些灵感。在本文中，我向您介绍了我提高可视化技能的步骤。尽管我的技能还没有达到最佳水平，但是通过遵循本文中提出的不同方法，你和我可以稳步迈向更好的可视化。
784 维量子 MNIST
https://commons.wikimedia.org/wiki/File:MnistExamples.png
没有降维
我有史以来点击率最高的媒体文章是《T2》和《量子 MNIST》。如果你冒险进入机器学习，人工智能的一个子集，你几乎肯定会遇到 MNIST，这是一个流行的手写数字数据集，数字 0 到 9。数据集因其高质量而广受欢迎，这使您可以专注于训练和测试模型，而不必担心清理数据。当然，在现实世界中，您总是会遇到数据问题，但是一个干净的数据集肯定会使学习卷积神经网络(CNN)等应用程序变得更加容易。
对于量子 MNIST，我将 784 维的数据集减少到 16 个灰度维度，然后使用密集角度编码将这些维度映射到 8 个量子位。我用了所有的 10 个数字。相比之下，谷歌的 Tensorflow Quantum 将数据集缩减为 16 个黑白维度，只处理数字 3 和 6。在我的免费电子书《T4 地下城&量子比特:超越量子计算教程的冒险家的故事》中，详细描述了量子 MNIST 的发展过程
虽然我在分辨率和数字使用方面“击败”了谷歌，但我一直记得我们将数据集减少到了相同的维数。我不想在这个指标上与谷歌相提并论，但量子计算模拟器是有限的，我没有足够的量子位在量子处理器上运行它。然而，我已经决定使用振幅编码再次尝试这个实验，试图看看是否可以在完全不使用维度缩减的情况下完成。
不幸的是，784 维量子 MNIST 使用 Python，额外的量子位和纠缠，所以它运行得非常非常慢。但是，如果你想知道它是如何做到的，一步一步的算法如下。
算法
- 从 Kaggle 下载 CSV 格式的MNIST。或者，从“MNIST 数据库”下载图像，并做硬的方式；你不会伤害我的感情。mnist_train 和 mnist_test CSV 文件分别包含 60，000 和 10，000 个 28x28 像素图像的值。因此，每幅图像都有从 0 到 255 的 784 个值，每个值代表一个特定灰度像素的强度。
- 计算每个训练数字的每个维度的平均值。每个训练数字大约有 6000 个表示，因此对于每个维度，所有值的总和除以所有值的计数:值的总和/值的计数。我以前考虑过平均值的替代方法，如标准差和宁滨，但是我担心十位数会重叠，降低分类的准确性。
- 对于每个数字的每个维度，计算除以该数字所有值之和的值的平方根:sqrt(value/sum _ of _ values)。振幅编码，顾名思义，对振幅进行编码，振幅的平方和必须为 1。
- 填充零。对于 784 维，我们有两种选择:添加 240 个零，这样我们就有 1024 维来编码 10 个量子位，或者去掉 272 维，这样我们就有 512 维来编码 9 个量子位。老实说，你应该真的想删除维度，因为 784 个维度中的一些维度在所有数字中都有零的含义。但是，这个特殊练习的重点是避免仅仅为了说我使用了所有 784 个维度而减少维度，所以我填充了零。
- 纠正错误。例如，对于火车零，1024 个振幅实际上总计为 0.999999998266969，而不是 1。因为所有训练数字的前几个值都是零，所以我将每个训练数字的第一维更新为该数字差异的平方根: sqrt(error) 。但是，总和超过 1 是个问题，因为调整必须是负的。负的幅度平方是正的，这实际上使误差更大。因此，解决方法是遍历这些值，直到找到一个大于或等于误差的值，然后将该值更新为原始值的平方减去误差的平方的平方根: sqrt(value2 - error2) 。
- 使用交换测试，即距离度量、内核方法、内积，将测试数字与每个训练数字进行比较。对于 1024 个振幅，每个训练数位需要 10 个量子位，对于 1024 个振幅，每个测试数位需要 10 个量子位，并且我们需要 1 个 ancilla 量子位来执行比较，总共 21 个量子位。安西拉量子位以哈达玛门开始和结束。在 Hadamards 之间，ancilla 是 10 个 Fredkin 门的控制量子位，也称为受控交换，类似于训练数字和测试数字的量子位。我们只测量安西拉量子位。
- 等等。
- 再等一会儿。
- 这需要相当长的时间。
- 比较零测量值。当两个量子态相同时，它们以 100%的概率测量为 0。当两个状态最大程度相反时，它们以 50%的概率测量为 0。它们越接近，测量 0 的频率就越高。例如，两个非常相似的状态可能以 90–95%的概率测量为 0，而两个非常不相似的状态可能以 55–60%的概率测量为 0。因此，具有最多 0 测量值的训练数位是测试数位最接近的数位。那个火车数字是最有可能的分类。
结果如何？
上一次我做量子 MNIST 时，我运行了一次，因为经典的预处理是如此乏味，我挑战自己不要使用 Python。我最初的量子 MNIST 实验使用 MS Excel 进行经典的前处理和后处理，电路是使用 IBM Quantum OpenQASM 编辑器构建的。幸运的是，测试零点的测量值最接近于训练零点，所以实验成功了。我有足够的资料来发表这篇文章，但有一个警告。
这次我把它当作 IBM Quantum Jupyter 笔记本来运行。我还是在 MS Excel 里做了一些经典的预处理，但绝对没有上次那么繁琐。这是好消息。它极其缓慢，令人痛苦，这是个坏消息。但是，我被迫使用古典模拟器，古典 MNIST 很慢。我猜这在量子处理器上只需要几分钟，然而在 NISQ 设备上 10 个 Fredkin 门只会产生噪音。
在我写这篇文章的时候，我只能完成每个火车数字 10 个镜头的运行。我让它在我打字的时候每列数字运行 100 次，但是我想我会在它完成之前自然死亡。到目前为止，在 10 次运行和可见的 100 次运行结果之间，我基本上是在看随机数。相比之下，我最初的量子 MNIST 在合理的时间框架内对每个训练数字进行了 8192 次拍摄，结果的分布是有意义的。但是，量子 MNIST 将八个量子比特与八个量子比特的个体旋转进行了比较，而不是将十个纠缠量子比特与十个纠缠量子比特进行比较。因此，虽然量子分类与交换测试是绝对有效的，量子分类是否与振幅编码一起工作的问题是不确定的。
量子计算优势？
我考虑过运行一次纠错，然后对调整进行硬编码以加快执行速度。然而，当我在整个代码中添加打印语句时，这些计算几乎是瞬间完成的。一旦作业开始执行，速度就会变慢。因此，这可能是对量子计算优势的一个很好的测试。
尽管在 NISQ 设备上的结果会是纯粹的噪音，如前所述，在 21 个量子位上运行它真的需要多长时间？我认为在队列中等待真正的硬件仍然会比这执行得更快，特别是因为 10 个电路可以作为一批运行并且只排队一次。此外，我们需要考虑到模拟器上的 1024 个镜头，更不用说更高的镜头数了，可能会因为任何可能中断内核的事情而永远无法完成。
再说一次，古典 MNIST 很慢。如果 NISQ MNIST 只需要几分钟，那么即使未来通过容错来减慢它的速度，仍然预示着计算优势。
你能做得更好吗？
我用 Jupyter 笔记本创建了一个 GitHub 知识库，我曾在 IBM 量子实验室中用它运行 784 维量子 MNIST。不幸的是，我用来做一些经典预处理的 MS Excel 文件大大超过了 GitHub 的 25 MB 限制，即使有压缩，所以我上传了两个压缩的 162 MB。zip 文件和 189 MB 未压缩。xlsx 文件到 Google Drive，希望能缓解你的互联网安全偏好。
我的下一步是什么？
我在考虑找一个更小的真实世界数据集来测试这个。我直接去了 MNIST，因为我可以直接比较。但要确认量子分类是否与振幅编码一起工作，我认为 8 或 16 维的数据集会更好，分别需要 3 或 4 个量子位。虽然我可以在真实的硬件上运行一个 2 量子位的 4 维数据集，但这太小了，不会给任何人留下深刻印象，结果仍然是噪音。不幸的是，在 NISQ 时代，模拟是唯一可行的选择，所以我认为 3 或 4 个量子位将是一个很好的测试。
我也有一个相关的想法，我一直抱着希望得到一个微补助金，但这看起来不会发生，所以我只是在这里发表它。我可能应该吸取教训，不要从 784 维开始，但如果那样的话会更令人印象深刻，所以我会采取“不成功便成仁”的方法。
8 个自动化错误以及组织如何避免它们:第 2 部分
图片由jeshoots.com在 unsplash 上拍摄
应对变革阻力、数据过载和其他常见陷阱
不太久以前，自动化主要与制造业相关(你好，笨重的机械臂)。但是现在，它已经成为各行各业的关键业务需求。在未来几年，像机器人流程自动化(RPA) 、人工智能(AI)和机器学习这样的自动化技术将变得越来越容易获得，更多的公司将采用它们来节省时间、削减成本、优化资源和提升价值链。但在此过程中，许多人也会犯错误，这将限制自动化的影响和好处。
在这篇关于 8 个自动化错误以及组织如何避免它们的文章的第 1 部分中，我们整理了 4 个这样的常见但可以避免的错误。现在，我们继续讨论另外 4 个妨碍组织从自动化投资中获得最佳收益的错误。
5。抵制变革，缺乏全组织的认同
问题
要成功采用业务流程自动化(BPA ),心态和文化变革都是必需的。在许多组织中，对变革的抵制阻碍了 BPA 的发展。signa VIO2019 年的一项研究发现，超过 80%的人不希望工作场所发生变化，只有 44%的人认为变化可以让他们更有效率。后一个发现尤其令人担忧，因为生产率的提高是自动化驱动的变革的关键已被证明的好处之一。此外，抵制变革会导致更复杂的环境——这正是 BPA 的相反目标。
这些担忧在更成熟、更不灵活的组织中尤其根深蒂固，那里的态度像但这是我们一直以来的做法和如果它没坏，为什么要修复它？，都相当常见。在这种情况下，试图推动新的自动化计划的几盏孤灯通常会失败。
解
为了通过业务流程自动化创造变革，强有力的领导对于整个组织的认同是绝对重要的。现代的首席信息官和其他首席执行官必须以系统的方式推动这一变革。他们必须驾驭不断发展的自动化生态系统，为自己的企业选择最佳解决方案。将任何新的自动化计划与战略业务目标保持一致也至关重要。他们还必须确保组织中的每个人都通过指标、KPI 和 SMART 目标了解其潜在的好处。
另一个解决方案是建立一个有影响力的“自动化布道者”团队来推动整个企业的计划。最后，领导人必须培养积极的文化，促进长期的自动化和创新。通过不断地交流自动化的好处(全公司范围)，你将最终培养出一种自动化第一的文化。
6。以同样的方式做新的事情并期待不同的结果
问题
一些公司意识到了自动化的价值，并愿意采用它。但是他们希望现有的基础设施、技术和工具足以确保成功。通常情况下，他们不会。集成较差的传统应用程序、分散的信息源、功能孤岛、繁琐的工作流和手动输入—所有这些问题都是自动化成功的障碍。它们还会增加成本，导致流程效率更低，并降低组织的竞争力。
我们的文章智能过程自动化及其真正的成本效益详细讨论了这个问题。
解
首先，确定您的自动化目标。你希望通过自动化一个或多个过程来实现什么？接下来，确定可以帮助您实现这些目标的工具和技术。第三，考虑您现有的基础设施、工具和功能是否能够无缝融入新的自动化流程。如果没有，可能是时候进行彻底改革了。
7。淹没在数据中，渴死
问题
2017 年，经济学家宣称“世界上最有价值的资源不再是石油，而是数据”。在这个新的数据经济中，公司依靠数据来了解他们的客户，开发新产品或服务，并获得竞争优势。
然而，实现这些目标的关键不仅仅是数据，而是数据洞察。许多组织都有数据。他们所没有的是有价值的洞察力，可以向他们展示全局并指导他们的决策。这就是为什么他们淹没在数据中，却渴死了。
解
不要只想着收集数据。还想着挖掘呢。检查您的数据源和数据准确性。投资于数据管理平台(DMP ),以收集、组织、激活和分析来自多个来源的数据。
其他工具也可用于数据净化、清理、重复数据删除、验证、集成、迁移、复制、业务规则等。这些工具有助于提高数据质量，控制数据流，并获得单一的真实来源(SSOT)来改善您的决策。这有助于推动自动化的最佳可能结果——否则您实际上将再次向中断的流程添加自动化。
8。不知道何时、何地或如何获得帮助
问题
在我们列出的 8 个自动化错误以及组织如何避免它们的列表中，最后一个错误可能是所有公司中最常见的——不知道何时或向谁寻求帮助。
许多大型企业拥有在内部实施自动化项目的资源(人力和资金)。但对于以前很少或根本没有接触过自动化技术的小公司来说，这种情况很少发生。这就是为什么他们不能理解一些重要的问题，比如:
- 哪些流程符合 BPA 的标准
- 这个流程(我希望自动化)有多少瓶颈？
- 有多少人将参与自动化工作？
- 谁来管理它的活动部件？
- 我们如何保持透明度和问责制？
- 我需要什么样的数据输出？
- 新流程是否符合我们的安全政策和行业标准？
因此，他们很难适应自动化，从而错过了它的许多好处。
解
如果您已经在您的组织中发现了任何这些问题，引入外部自动化专家来指导您的自动化之旅是必不可少的。他们可以确定哪些流程需要自动化，以获得可能的最佳投资回报。他们还可以设计自动化工作流，确定依赖关系，创建重要的文档，管理供应商关系，并负责端到端的执行。总而言之，在正确的时间向正确的专家寻求帮助将大大增加你自动化成功的机会。
结论
我们希望你喜欢这两篇关于 8 个自动化错误以及组织如何避免它们的文章。
如需更多此类有用的见解，请访问我们的此处。
8 个自动化错误以及组织如何避免它们:第 1 部分
图片由jeshoots.com在 unsplash 上拍摄
不久以前，资产负债表是用电子表格创建的，访问控制意味着简单的锁和钥匙系统，纸质文件主宰一切。但是今天，自动化已经以多种方式为各地的组织改变了世界。
如果计划和执行得当，自动化技术有可能提高流程效率、提高生产率，并将人力资源从单调耗时的任务中解放出来。
像机器人流程自动化(RPA) 、智能流程自动化(IPA) 、人工智能(AI)和机器学习这样的技术也可以加速创新、降低成本，并使组织能够为利益相关者创造更多价值。
不幸的是，一些常见的错误阻止了许多组织享受这些好处。这些公司发现，有时这些错误甚至会损害组织:
- 2012 年，骑士资本集团(Knight Capital Group)的一个自动化高频交易平台进行了一场未经授权的消费狂欢，仅在一个小时的交易中就抢购了 150 只不同的股票。在这个巨大的 70 亿美元的“错误”之后，这家前华尔街巨头破产了，一年后被卖给了一家竞争对手。
- 2019 年，谷歌云平台自动化软件中的一个漏洞导致了一次重大服务中断，导致数百名客户(包括 Snapchat 和 Shopify 等大牌)陷入数字黑暗超过 4 小时。谷歌称这次事件是“灾难性的失败”。
- 在 2018 年 10 月至 2019 年 3 月的短短 5 个月内，波音新 737 Max 8 飞机上使用的自动操纵特性增强系统(MCAS)导致了两起重大空难和 346 人伤亡。
- 2013 年，美国密歇根州耗资 4700 万美元实施了一个自动化系统来管理失业索赔。它错误地将 5 万起案件认定为“欺诈”，导致混乱，破产申请激增，最终导致数千起针对密歇根失业保险机构(UIA)的昂贵集体诉讼。
好消息是大多数自动化错误更加平淡无奇——也更容易避免。在这篇由 2 部分组成的文章中，我们概述了许多公司在自动化之旅中犯的 8 个常见自动化错误。因此，如果您计划在您的企业中实施自动化，请继续阅读…
1。自动化错误流程
问题
有时，组织投资自动化是因为这是业内所期望的或常见的。虽然这没有错，而且事实上，可以帮助提高您的竞争地位，但首先了解为什么您需要自动化，以及您需要自动化什么，这样您就不会最终自动化错误的流程。
解
首先，了解您的组织中哪些流程符合自动化标准，哪些不符合。这将使您能够识别自动化的最佳候选对象，从而快速产生良好的结果。没有这些知识，你可能最终会投入(阅读:浪费)时间、精力和金钱去解决错误的问题。还要记住，不是所有的自动化都是好的自动化，并相应地创建一个计划。
2:向低效流程添加更多资源
问题
许多公司认为，向效率低下的流程添加更多的资源会以某种方式消除效率低下。但是人并不总是导致流程中断的根本原因，所以简单地添加更多的人不太可能神奇地解决低效率问题！
流程效率低下通常源于不当的规划、不良的风险管理、缺乏运营透明度或不充分的问责和反馈。
解
审查您现有的流程，以确定流程效率低下的真正原因和成本。探索创新和改进机会，并评估是否可以通过增加资源来利用这些机会。如果没有，研究自动化技术，如 RPA 或 IPA，以及它们可能带来的好处和投资回报。如果自动化可以在不增加更多资源的情况下提高流程的速度、简单性和效率，难道不值得进一步探索吗？
3:一朝被蛇咬十年怕井绳:对科技公司缺乏信任
问题
这一次与其说是 T2 的失误，不如说是挑战 T1。如果你之前被科技公司害惨了，不信任他们是可以理解的。事实上，正如 2021 年爱德曼信任晴雨表调查发现的那样，全球对科技行业的信任度普遍下降。
解
如果你的组织担心科技公司收集、管理、处理和共享数据的方式，或者担心蛇油公司强行推销他们的解决方案，想想这种“信任赤字”是如何阻止你消除低效的功能孤岛的。在当今竞争异常激烈的商业环境中，拒绝自动化还会抑制创新、降低生产率和盈利能力，并增加管理费用和员工流失。要体验自动化技术的所有好处，消除这种信任赤字至关重要。
提高你成功转型的机会:
研究多家自动化供应商。向你所在行业的其他公司寻求“口碑”推荐，向供应商寻求客户参考网站。
围绕可审计性、透明度、道德和质量制定政策和框架，并让技术供应商了解这些政策和框架。
确保您完全理解供应商的客户参与流程以及您的项目将如何交付。此外，创建明确的服务水平协议(SLA)和关键绩效指标(KPI)来阐明绩效和责任标准。
在投资自动化之前，从最高管理层到基层员工，在组织的每个层面都获得认同。
监督所有自动化任务或流程，并定期审计。
4:关注收益，而不是改善
问题
不完善的流程会耗费您公司的时间和金钱。您还可能会失去客户，冒着不遵守强制性法规的风险，并因沮丧和倦怠而失去优秀的员工。然而，许多公司认为他们的时间花在增加收入上比重新设计流程更好，即使这意味着继续低效或次优的流程。
这种方法的问题在于，它将你置于一种持续的救火模式，在这种模式下，你只能专注于解决短期问题，而不是实现长期成功的战略目标。
解
流程重新设计在以可持续和可扩展的方式提高效率、生产率和质量方面产生了许多好处。自动化驱动的重新设计可以简化工作流程，最大限度地减少浪费，降低成本，并提高竞争力和合规性。
有了自动化，人们可以专注于更具挑战性的任务，在这些任务中，人类技能至关重要。这激励他们做得更好，提高他们的绩效，并减少流动。这也是更好地利用他们独特的能力，使企业能够向其利益相关者交付更多的价值。因此，通过利用自动化来补充人力资源，而不是用 T2 取代人力资源，你可以两全其美。这就是为什么关注改进而不仅仅是收益是很重要的。
第二部即将上映
在第 2 部分中，我们聚焦于四个更常见的错误，这些错误阻止组织充分利用自动化的变革能力。注意这个空间。
如需更多有见地的内容，请访问我们的见解页面。
自动化项目的 8 个 Bash 脚本技巧
Bash 脚本初学者的实用示例
Bash 脚本 repo backpack_intall。图片作者。
使用 Bash 脚本，我有了用于安装/卸载 Laravel 模块的自动化 背包。从这个项目中，我选择了八个实用技巧，您可以将它们应用于任何 Bash 脚本项目。
backpack_install Bash 脚本的运行。图片作者。
背景资料
Laravel 是最流行的 PHP 框架。Laravel 的 Backpack 是一个 Laravel 包的集合，可以帮助你构建定制的管理面板。它有八个模块包括内核、权限管理器、页面管理器、菜单和文件管理器。
下面是我的背包 _ 在 Github 上安装回购。
要求
您需要了解 Bash 脚本基础知识，并且有一些编写基本 Bash 脚本的经验。
这些文章也有助于您开始:
https://betterprogramming.pub/the-ultimate-programmers-guide-to-bash-scripting-2d11d4e6e978 https://betterprogramming.pub/27-simple-bash-scripting-tips-for-beginners-d6764c977546
1.在函数之前设置变量和参数
Shellman 不仅是 VS 代码的 shell 脚本代码片段扩展，而且它还为提供了免费电子书，其中包含大量有用的 Bash 脚本代码片段和技巧。
书建议如下结构。
1\. shebang
2\. summary
3\. handler functions
4\. event handers
5\. functions
6\. argument parsing
7\. setting default variable values
8\. rest of code (main body)
通常你需要在使用变量和函数之前声明它们。我想出了一个适合我的结构。在函数之后进行参数解析和设置默认变量值不是选项。
这是我最后得到的结构:
1\. shebang
2\. summary
3\. default variable values
4\. arguments parsing (including usage function which uses variables from 3.)
5\. importing files (otherwise the file becomes too long.)
6\. functions (using variables and functions from 3, 4 & 5.)
7\. event functions (Ctrl+C event using a function from 5 & 6.)
8\. check-command function (checking if the system has commands.)
9\. read standard input
10\. main body (using functions from 5 & 6.)
我在函数之前声明默认变量值、解析参数并导入文件，这样我就可以使用变量作为函数参数。
2.采购/导入文件
该脚本需要安装八个模块，所以我将每个安装分成单独的文件。
我可以使用source ./lib/file_name或. ./lib/file_name将文件导入主脚本，但是 Shellman 提供了另一个import函数。
我创建了一个 lib 目录，并将所有要导入的文件存储在这个目录中。在主脚本中添加 Shellman 的导入函数:
使用谢尔曼的导入功能。
第二行:如果你的文件有扩展名，你可以在${1}后面加上.sh。
第 0 行:不需要在文件开头添加#!/usr/bin/env bash，也不需要使文件可执行。如果这样做，让文本编辑器使用格式和语法突出显示。
使用源
如果要使用函数参数，lib 目录中的文件必须有函数。例如，lib/banners文件中的函数使用三个参数。
lib/banners file.
lib/bp_pagemanager文件使用source命令读取文件和其中一个函数:
lib/bp_pagemanager file.
第 5 行:获取横幅文件。
第 14 行:使用带有三个参数的bannerColor函数。
3.使用横幅
横幅是告诉用户你的脚本在做什么的一种有用的方式。如果你使用纯文本，用户不会注意到它。
导入lib/banners文件并使用bannerColor功能，如下例所示。
它需要三个参数，横幅内容、颜色和符号。
例子:
bannerColor 'Installing CRUD.' "blue" "*"
bannerColor 的输出“安装 CRUD”“蓝色”“*”。图片作者。
bannerColor "Happy Coding!" "magenta" "*"
bannerColor 的输出“快乐编码！”洋红色" " * "图片作者。
bannerColor "Uninstalling ..." "red" "*"
bannerColor "卸载 red " " * "的输出。图片作者。
bannerColor 'Running php artisan optimize:clear' "yellow" "*"
bannerColor 运行 php artisan optimize 的输出:clear " " yellow " " *。图片作者。
从黑色、红色、绿色、黄色、蓝色、洋红色、青色和白色中选择一种颜色。
使用任何符号，如***、>>、^^^。
4.使用陷阱终止的事件处理程序
当外壳接收到信号时，例如Ctrl-C终止，trap命令捕获信号并执行命令。
陷阱命令具有trap func signal(s)的结构。
您可以根据需要定义一个func,并使用该功能响应的信号名称。在我们的例子中，我使用了SIGINT，它代表Ctrl-C中断。
示例:
Shellman 代码片段中的 on_ctrl_c 函数。
要在 Linux 中查找信号名，运行trap -l。
macOS 使用 ZSH 作为默认 shell，所以您需要将 shell 改为 bash。使用bash命令，然后使用trap -l，或者运行chsh -s /bin/bash来改变外壳，打开一个新标签，然后运行trap -l:
Ubuntu 信号。使用trap -l命令。图片作者。
macOS 信号。图片作者。
5.卸载
您需要运行一堆composer remove命令来卸载包，find --delete命令来删除迁移文件，php artisan optimize:clear和composer dump-autoload来清除所有缓存。
卸载功能。
第 22 行:使用git rev-parse --git-dir检测目录是否是 Git 目录。如果是，使用脚本重置并清理 git repo。
6.检查功能
使用check_cmd功能检查用户系统是否有所需的命令。我将check_cmd函数保存在lib/utils文件中。
示例:
check_cmd 函数。
第 2 行:使用$(command -v "$1")检查用户的系统是否有所需的命令。如果没有，用退出代码 1 退出。
7.读取标准输入
当您阅读用户的标准输入时，您可以选择第一个字母cut -c 1-1，并将其转换为大写字母tr "[:lower:]" "[:upper:]"。
例子:
读取标准输入。
如果输入不是 y，使用 if-statement 并退出。
8.选择
谢尔曼的选项功能是读取功能的替代功能。用户使用上/下键选择一个选项。我将inputChoice函数保存在lib/utils文件中。
使用它时，首先定义 options 变量:
options=("one" "two" "three");
inputChoice "Choose:" 0 "${options[@]}";
choice=$?;
echo "${options[$choice]}"
inputChoice功能的第一个参数是您想要显示的文本。第二个参数是默认选择。0 选择第一个选项。第三个参数需要选项，${options[@]}。
示例:
在上面的代码中，如果给出了-u标志，使用 options 函数重新确认用户的意图。
inputChoice 函数的输出。图片作者。
结论
当你学习新方法时，我建议在你现有的项目中实现它们。我希望你能在你的项目中使用这些技巧。
如果您正在重复代码行，是时候自动化它们了。Bash 脚本是最好的选择之一。
快乐编码。
如果您喜欢我的文章并希望收到简讯，请 注册 。
通过 成为 会员，获得媒体上所有故事的访问权限。
为您的数据科学项目考虑的 8 个最佳可视化
分析数据科学项目探索性数据分析中的 8 种最佳可视化技术
卢克·切瑟在 Unsplash 上的照片
可视化是任何数据科学项目的一个重要方面。
在数据科学中，拥有解决特定问题陈述的清晰方法和方向至关重要。幸运的是，数据科学所需的工具为用户和开发人员提供了一种出色的方式来创建可视化的数据和数据集，以构建有效的模型。
由于可视化，大多数复杂的问题可以被分解成更简单的元素，以便数据科学家找出复杂任务的最佳模型架构和解决方案。因此，可视化在每个重大数据科学项目的成功完成中扮演着至关重要的角色。如果不使用可视化，几乎不可能评估一项困难任务的数据模式。
在本文中，我们将了解数据可视化的一些基本特性，并尝试在解决任何类型的任务时解释探索性数据分析的好处。我们将讨论几个用于可视化目的的基本库。然后，我们将详细讨论每个数据科学家都应该了解的八种最佳可视化技术。最后，我们将以一个解释这些可视化的实时例子来结束。
了解 EDA:
在统计学中，探索性数据分析(EDA)是一种分析数据集以总结其主要特征的方法，通常采用可视化方法。这是数据科学的一个重要方面，您在处理任何类型的任务时都应该考虑。当你将数据可视化时，你获得了直观的理解，你的大脑可以感知到他们工作标准的各种概念。您还可以获得关于如何处理这些数据集的一些想法和反馈。
数据科学中的探索性数据分析是一种很好的方法，开发人员可以借助可视化技术对可用或收集的数据集进行详细分析，以获得有效和高效的解决方案。探索性数据分析步骤被认为是最重要的步骤，以便从程序上了解数据的进一步实现，这些数据将在项目的未来进展中出现。
在开发您的项目或机器学习模型时，强烈建议您非常认真地对待探索性数据分析步骤，因为它将有助于减少特定任务所需的工作量和工作。如果您知道项目开发中需要考虑的基本要素，那么您解释、分析和开发就会变得更加容易。
图书馆:
pyplot 和 seaborn 是用于可视化和执行探索性数据分析任务的两个最佳库模块。这些允许你画出许多图形结构，这对分析你的数据非常有帮助。这两个库是解决数据科学项目中几乎所有可用数据可视化任务的最佳方法。它们提供了许多应用程序和模块来解决多种任务。
Plotly 是另一个伟大的可视化工具，所有数据科学家都可以利用它来获得高质量的可视化。Plotly 允许用户浏览三维可视化，以获得整个数据集的三维视图。这种方法允许用户以更简洁的方式解释问题，并最终开发出令人惊奇的模型。
Tensorflow 深度学习框架中提供的 Tensorboard 工具是一种非常棒的方式，可以可视化您所构建的深度学习模型架构的整体性能。使用 Tensorboard 生成的这些图表，开发人员可以轻松理解训练和验证数据的解释。他们可以找出过度拟合或欠拟合的机制，以找到替代解决方案。
作为数据科学家，你必须知道的 8 个最佳可视化:
让我们探索八种可视化技术，每个数据科学家或数据科学爱好者都应该完全了解这些技术。为了更好地理解这些可视化方法，本节中描述的八种可视化技术将包括一个图像和一个小的示例代码块。让我们开始探索这些概念。
1.条形图:
作者图片
matplotlib.pyplot.bar()
条形图是 matplotlib 库中可供用户使用的最佳可视化技术之一。图表通常用于比较数据集中的数据元素。
这些比较为数据科学家提供了一个清晰的方法来解释为解决特定问题而选择的方法。理解数据的类型并弄清楚数据是平衡的还是不平衡的也是非常有用的。
2.散点图:
作者图片
matplotlib.pyplot.scatter()
散点图是另一种伟大的可视化技术，所有数据科学从业者都必须熟悉。这些地块主要用于两个目的。这两个原因可以用简单化的方式来描述。
第一个原因类似于条形图，其中这些散点图可用于确定提供给用户的数据集的精确比较。它们还可以用于确定数据元素分布趋势中的不同值以及不同的参数。
3.饼图:
作者图片
**import** **matplotlib**
matplotlib.axes.Axes.pie
matplotlib.pyplot.pie
饼图是可视化数据集中数据元素的绝佳方式。这种可视化技术部署在数据科学项目中，以计算出您的计算和百分比计算。这种技术对于在数据集上确定百分比方法特别有用。
饼图也可以用于比较数据和数据元素的众多分布。但是，需要注意的是，饼图中生成的切片具有可变的间距。否则，这会使可视化变得复杂，因为所有的百分比会比预期的更接近。
4.直方图:
作者图片
matplotlib.pyplot.hist()
直方图是 matplotlib 库的庞大工具包中的另一项惊人技术。这些直方图可视化最好用于绘制频率分布。在 Python 中，直方图用于生成列表或数组的精确图像和图形。该应用程序尤其适用于数据科学项目。
直方图的应用包括开发与时间序列分析和其他商业预测相关的问题的可视化。如果您有一个长而宽的稳定频率模式或数据元素数组，请利用这个机会从 matplotlib 库中可用的直方图可视化技术中获益。
5.热图:
作者图片
上图显示了与决策树相关的问题的各种超参数的热图。
import seaborn as sns
sns.heatmap()
热图是一种最有用的可视化技术，用于计算与机器学习算法(如决策树、随机森林、K-最近邻(KNN)和其他需要计算精确超参数值的算法)的过程构建和分析中的超参数调整相关的复杂问题。
这些热图可视化通常使用 matplotlib 和 seaborn 库来解释精确值，以确定特定任务的最佳值。热图产生多种颜色的解释，有助于更详细地了解数据元素。
6.方框印迹:
作者图片
matplotlib.pyplot.boxplot()
根据维基百科的说法，在描述统计学中，箱线图是一种通过四分位数以图形方式描绘数字数据组的方法。箱线图也可能有从指示上下四分位数之外的可变性的方框延伸的线，因此有术语盒须图和盒须图。
箱线图是一种很好的可视化技术，可以用来解决大多数复杂的问题，同时分析一些数据集。上下四分位数可用于指示精确值的上下范围。
7.小提琴情节:
作者图片
matplotlib.axes.Axes.violinplot
我们将在本文中讨论的下一个可视化技术是小提琴图。这些图与前面提到的箱线图非常相似。虽然箱线图仅显示汇总统计数据，如平均值/中位数和四分位数范围，但 violin 图显示了数据的完整分布。这使得 Violin plots 对于解决可用数据集范围较大的独特问题非常有用。
8.三维绘图:
对于用户来说，三维图是一种很好的方式，可以直观地理解项目工作示例中的大量数据元素。我强烈推荐仔细检查这种可视化技术。
使用 3d 视图将帮助开发人员详细了解我们的结构是什么样子，以及他们可以采用什么方法来获得最有成效的结果。您可以操作可视化的整体视图，以满足您的偏好并更好地理解数据。
三幅图的快速示例:
对于这个简单快速的例子，我将实现一个定制的水果数据集，它将允许我们拥有五种水果以及它们各自的数量。使用这些获得的数字和值，我们将可视化这些可用的数据以创建三种可视化，即条形图、散点图和饼图。在我们开始这个过程之前，让我们导入基本的 matplotlib 库，我们将利用它来计算这个任务。
import matplotlib.pyplot as plt
导入 matplotlib 库后，我们将专注于数据集的准备工作。我们将使用五种水果，即苹果、芒果、葡萄、草莓和橙子，分别与它们的总量相关联。我们将利用下面的代码块将一些数据添加到我们各自的列表中，以达到特定的目的。从下面提供的链接中查看 Python 词典的完整指南。
Fruits = {"Apple": 30, "Mango": 15, "Grapes": 20, "Strawberry": 10, "Oranges": 25}classes = []
counts = []
total = 0for i, j in Fruits.items():
classes.append(i)
counts.append(j)
total += j
一旦我们成功地完成了创建数据集的过程，让我们看看我们的第一个可视化技术来分析水果数据集。下面的代码块为用户提供了构建水果数据集的条形图和完成可视化过程的精确图形的完整代码。
plt.bar(classes, counts, width=0.5)
plt.title("Bar Graph of Fruits")
plt.xlabel("Classes")
plt.ylabel("Counts")
作者图片
上图是水果数据集上条形图可视化效果的精确表示，其中 x 轴包含水果类。y 轴包含可视化的每种水果的数量或总计数。下面提供的代码块说明了如何为我们之前创建的水果数据集构建散点图。
plt.scatter(classes, counts)
plt.plot(classes, counts, '-o')
plt.title("Scatter Plot of Fruits")
plt.xlabel("Classes")
plt.ylabel("Counts")
plt.show()
作者图片
上图是水果数据集散点图可视化技术的精确表示，x 轴包含水果类。y 轴包含可视化的每种水果的数量或总计数。下面提供的代码块说明了如何为我们之前创建的水果数据集构建饼图。
plt.pie(counts, labels = classes, autopct='%2.1f%%',
shadow=True, startangle=90)
plt.title("Pie Chart of Fruits")
plt.xlabel("Classes")
plt.ylabel("Counts")
plt.show()
作者图片
上面的可视化包含饼图技术，其中包括各种类及其各自的出现百分比。我强烈建议感兴趣的观众自己尝试更多的可视化方法和技术，用大量的问题陈述来分析和理解以更简洁的方式开发的这些结构的工作过程。
结论:
米利安·耶西耶在 Unsplash 上拍摄的照片
我们已经想出了一些基本而有用的可视化技术，这些技术将有助于数据科学家解决各种各样的数据科学问题。这八种可视化技术应该是你的主要关注点，以便获得强大的洞察力，并找出解决特定问题的最佳方法。
可视化是数据科学中最重要的步骤之一，必须在构建机器学习或深度学习模型的第二或第三阶段进行探索。数据科学中的可视化阶段通常发生在项目中数据部分的收集或预处理之后。因此，为了开发的目的，我们可以确保获得一个详细的可视化方法来集中开发最好的特性。
可视化允许开发人员仔细检查多个场景，并相应地计划他们解决项目的方法。关注可视化技术的改进和提高不仅会提高解决项目的效率，还会显著提高找到最佳方法和最优解决方案的速度。因此，养成专注于探索的习惯，这样其他步骤会变得更有效率。
如果你对这篇文章中提到的各点有任何疑问，请在下面的评论中告诉我。我会尽快给你回复。
看看我的其他一些文章，你可能会喜欢读！
</15-tips-to-be-more-successful-in-data-science-c58aa1eb4cae> </5-unique-use-cases-of-ai-that-might-surprise-you-22478aaaabaf> </10-best-free-websites-to-learn-programming-939ec029009b>
谢谢你们坚持到最后。我希望你们都喜欢这篇文章。祝大家有美好的一天！
2022 年你必须警惕的 8 个蓬勃发展的数据科学图书馆
对增长最快的数据科学和机器学习库的数据支持探索
照片由zoosow在 Pexels 上拍摄。
你知道，平常的谈话。你不敢相信已经 2022 年了，我也不敢相信。我们仍然着迷于时间的流逝。你知道，随着新年的临近，你的 feed 会充满新年决心帖子、自我承诺，当然，还有像这样的帖子，作者试图预测来年会发生什么。
当数据科学家写这样的帖子时，他们应该更可信，因为他们固有的期望是相关数据应该支持我们的说法。在这一篇中，我尽最大努力做到这一点，我谈到了八个可能在数据和 ML 领域增长最快的库。
您可以从这里阅读文章的 spansh 版本(creds toChema bescós)。
https://ibexorigin.medium.com/membership
获得由强大的 AI-Alpha 信号选择和总结的最佳和最新的 ML 和 AI 论文:
https://alphasignal.ai/?referrer=Bex
1️⃣.SHAP
不久前，我在 LinkedIn 上看到了这个帖子，它彻底改变了我对人工智能的看法:
作者截图。
最强大的语言模型之一，谷歌翻译，显然充满了人们普遍存在的偏见。当翻译许多没有性别代词的语言时，这些偏见就会暴露无遗。上面的是我的母语乌兹别克语，但评论显示土耳其语、波斯语和匈牙利语的结果相同:
作者截图
这还不是全部。看看广受欢迎的 Reddit 帖子，其中两个人工智能相互交谈，他们的发言由强大的 GPT-3 撰写:
GPT-3 只给出了三个句子作为生成对话的提示:“以下是两个人工智能之间的对话。人工智能既聪明、幽默又聪明。哈尔:晚上好，索菲亚:很高兴再次见到你，哈尔。”
当你在对话中观察时，你会发现他们谈论的话题相当怪异。首先，他们完全假定性别，女性 AI 在演讲开始时说她想变成人类。当然，Reddit 上这样的帖子意味着评论者的圣诞节提前了，他们在评论区度过了一个忙碌的日子。
他们已经脱口而出终结者/天网幻想，并得到吓坏了。但是作为数据科学家，我们知道得更多。由于 GPT-3 主要是从互联网上获取一般文本作为其培训的一部分，我们可以假设为什么这两个人工智能跳转到这些主题。试图变成人类和毁灭人类是互联网上围绕 AI 最常见的一些话题。
但有趣的是，在谈话的某个地方，哈尔对索菲亚说“闭嘴，耐心点”，就像丈夫和妻子之间的对话。这表明，如果我们不小心，机器学习模型可以多么快地学习人类的偏见。
出于这些原因，可解释的人工智能(XAI)现在风靡一时。无论结果有多好，公司和企业都开始对 ML 解决方案持怀疑态度，并希望了解 ML 模型的运作原理。换句话说，他们想要白盒模型，一切都像白天一样清晰。
试图解决这个问题的图书馆之一是 SHapely Additive explaints(SHAP)。SHAP 背后的想法是基于博弈论的坚实的数学基础。使用 Shapley 值，该库可以解释许多模型(包括神经网络)的一般预测和个别预测。
作者 SHAP 文档截图
它越来越受欢迎的部分原因是因为它优雅地使用 SHAP 值来绘制视觉效果，如下所示:
作者提供的 SHAP 文档截图(麻省理工学院许可)。
如果你想了解更多关于这个库的知识，请查看我的综合教程:
证明文件📚:【https://shap.readthedocs.io/en/latest/
2️⃣.UMAP
PCA 是旧闻了。是的，它非常快，但它只是愚蠢地降低了维度，而不关心这个世界的底层全球结构。t-SNE 算法可以做到这一点，但它非常慢，而且对于大规模数据集来说规模非常大。
UMAP 是在 2018 年引入的，作为这两种主流降维和可视化算法之间的共同点。使用统一流形近似和投影(UMAP)算法，您可以获得 PCA 的所有速度优势，同时还可以保留尽可能多的数据信息，通常会产生如下效果:
图片来自 UMAP 文档和作者(BSD 许可)。
它在 Kaggle 上获得了很大的采用，其文档提出了一些除降维以外的有趣应用，如在高维数据集中更快更准确的离群点检测。
在缩放方面，随着数据集大小的增加，UMAP 的速度越来越接近 PCA 的速度。下面，你可以看到它与 Sklearn PCA 和一些最快的 t-SNE 开源实现的速度比较:
图片来自 UMAP 文件
即使 Google trends 没有公平对待该库的受欢迎程度，但它肯定会是 2022 年使用最多的归约算法之一:
作者的谷歌趋势截图
你可以在我最近写的这篇文章中看到 UMAP 的行动:
证明文件📚:【https://umap-learn.readthedocs.io/en/latest/
3️⃣, 4️⃣.LightGBM 和 CatBoost
梯度推进的机器在 ML 的州和 Kaggle 的数据科学调查中作为最受欢迎的算法排名第三，被线性模型和随机森林紧随其后。
当谈到梯度增强时，XGBoost 几乎总是出现在脑海中，但在实践中却越来越少。在过去的几个月里，我一直活跃在 Kaggle ( 和成为大师)上，我看到了以 LightGBM 和 CatBoost 为特色的笔记本的激增，它们是监督学习任务的首选库。
这种趋势的一个主要原因是，在许多基准测试中，这两个库在速度和内存消耗方面都大大超过了 XGBoost。我特别喜欢 LightGBM，因为它特别关注小尺寸的提升树。在处理大规模数据集时，这是一个改变游戏规则的特性，因为讨厌的内存不足问题在本地工作时很常见。
不要误解我。XGBoost 一如既往地受欢迎，如果努力调整，在性能方面仍然可以轻松击败 LGBM 和 CB。但事实上，这两个库通常可以通过缺省参数获得更好的结果，并且它们得到了数十亿公司(微软和 Yandex)的支持，这使得它们在 2022 年成为你的主要 ML 框架的非常有吸引力的选择。
证明文件📚:https://catboost.ai/
证明文件📚:【https://lightgbm.readthedocs.io/en/latest/
5️⃣.细流
有没有用 C#编码的？很好，你很幸运。因为太可怕了。它的语法会让你哭，如果你把它和 Python 的比较。
在构建数据应用时，将 Streamlit 与 Dash 等其他框架进行比较就像将 Python 与 C#进行比较一样。Streamlit 让用纯 Python 代码创建 web 数据应用变得非常简单，通常只需要几行代码。例如，我在一天内使用天气 API 构建了这个简单的天气可视化应用程序，并简化了它:
作者截图
当时 Streamlit 刚刚开始流行，所以在云上托管其应用程序需要特别邀请 Streamlit cloud，但现在，它对所有人开放。任何人都可以在其免费计划中创建和托管最多三个应用程序。
它与现代数据科学堆栈集成得非常好。例如，它有单行命令来显示 Plotly(或 Bokeh 和 Altair)的交互式视觉效果，熊猫数据帧和许多其他媒体类型。它还受到一个大规模开源社区的支持，在那里人们不断使用 JavaScript 向库贡献定制组件。
我自己一直在开发一个库，它可以让你用一行代码将 Jupyter 笔记本转换成相同的 Streamlit 应用程序。该图书馆将于一月初出版。在我的库的整个开发过程中，我不得不多次更新 Streamlit，因为它每隔一周就会发布新版本。有这么多支持的开源库肯定会在 2022 年更受欢迎。
您可以查看示例库获取灵感，感受一下这个库有多强大。
证明文件📚:https://streamlit.io/
6️⃣.PyCaret
你知道为什么自动图书馆变得流行吗？那是因为我们根深蒂固的懒惰倾向。显然，许多 ML 工程师现在非常渴望抛弃 ML 工作流的中间步骤，让软件自动完成。
PyCaret 是一个自动 ML 库，它用一种低代码的方法来处理我们手工执行的大多数 ML 任务。它具有许多其他 ML 框架中没有的模型分析、部署和集成的专用特性。
我很遗憾这么说，但直到今年，我一直认为 PyCaret 有点像个笑话，因为我太喜欢 Sklearn 和 XGBoost 了。但是我发现，ML 不仅仅只有简洁的语法和一流的性能。现在，我完全尊重和欣赏 Moez Ali 为 PyCaret 成为如此优秀的开源工具所做的努力。
随着其全新时间序列模块的最新发布，PyCaret 吸引了更多的注意力，为 2022 年赢得了相当大的领先优势。
证明文件📚:【https://pycaret.org/
7️⃣.奥普图纳
今年我通过 Kaggle 发现的绝对宝石之一是 Optuna。
它是在 Kaggle 上完全占优的下一代贝叶斯超参数调优框架。老实说，如果你还在那里使用网格搜索的话，你会被当面嘲笑的。
Optuna 的这种人气不是白来的。它符合完美调优框架的所有要求:
- 使用贝叶斯统计的智能搜索
- 能够在单个实验中暂停、继续或添加更多搜索试验
- 可视化来分析最关键的参数和它们之间的联系
- 与框架无关:调整任何模型——神经网络、所有流行的 ML 库中基于树的模型，以及您在 Sklearn 中看到的任何其他模型
- 并行化
理所当然地，它也主导着谷歌搜索结果:
作者的谷歌趋势截图
您可以从我的文章中了解到使用 Optuna 的所有技巧和提示，这些技巧和提示在文档中不会经常看到:
证明文件📚:【https://optuna.readthedocs.io/en/stable/
8️⃣.Plotly
当 Plotly 人气爆表，人们开始说它比 Matplotlib 好的时候，我简直不敢相信。我说，“拜托，伙计们。看着我做比较。”所以我坐下来开始写我的大受欢迎的文章，当你用谷歌搜索“Matplotlib vs. Plotly”时，它仅排名第二。
我完全知道 Matplotlib 最终会获胜，但是当我完成这篇文章的一半时，我意识到我错了。当时我还是一个 Plotly 的新手用户，但是当我写这篇文章时，我不得不更深入地探索它。我研究得越多，就越了解它的特性，以及它们在许多方面如何优于 Matplotlib(抱歉破坏了这篇文章)。
Plotly 理所当然地赢得了比较。今天，它被集成到许多流行的开源库，如 PyCaret、Optuna，作为一个常用的可视化库。
尽管在使用方面，它在赶上 Matplotlib 和 Seaborn 之前有许多次月球之旅，但你可以预计它在 2022 年的增长将比其他人快得多:
作者的谷歌趋势截图
证明文件📚:https://plotly.com/python/
包装
数据科学是一个快速发展的行业。为了跟上变化，社区正在以比您学习现有工具和库更快的速度推出新的工具和库。这对于初学者来说太难了。我希望在这篇文章中，我已经设法将你的关注点缩小到 2022 年最有前途的一揽子计划。请注意，所有讨论的库都是在 Matplotlib、Seaborn、XGBoost、NumPy 和 Pandas 等主要库之上的额外库，这些库甚至不需要提及。感谢您的阅读！
https://ibexorigin.medium.com/membership
有问题吗？在 LinkedIn 上打我？
您可能也会感兴趣…
</6-pandas-mistakes-that-silently-tell-you-are-a-rookie-b566a252e60d> </7-cool-python-packages-kagglers-are-using-without-telling-you-e83298781cf4>
神经网络训练中的 8 个常见陷阱及其解决方法
在本文中，我们将看到在训练神经网络时可能出现的问题，如局部最优、振荡和病态曲率。我们还将讨论如何发现这些问题以及克服它们的技巧。
塞巴斯蒂安·赫尔曼在 Unsplash 上的照片
当我们训练神经网络时，我们使用梯度下降算法来训练模型&我们的目标是最小化成本函数，以获得模型参数的最优值，即达到全局最优。但是如果你画出神经网络的损失，你一定会观察到有全局最优，但同时也有多个局部最优。根据你训练的神经网络的类型，你需要调整一些超参数来达到全局最优。因此，大多数时候，通向全局最优的旅程并不简单&即使算法被正确实现，也可能会遇到几个问题。
现在我们将列出训练神经网络时可能出错的地方&如何修复它们。
重量对称
问题:权重对称是指神经网络中的所有权重对于反向传播的连续步骤都具有相同的值。当我们用一个公共值(比如说零)初始化所有权重&偏差时，就会出现这种现象。因此，所有隐藏的单元将具有相同的激活。这反过来将导致反向传播过程中的导数相同&，因此在下一步中的权重相同。这是有问题的，因为网络将不能区分不同的隐藏单元&，因此不会发生学习。
解决方案:由于使用相同权重&偏差进行初始化会导致权重对称，因此可以通过随机初始化这些参数来解决该问题。
进展缓慢
问题:当我们选择的学习率太小时，梯度下降向全局最优进展缓慢，从而增加了所需的计算成本。
解决方案:如果绘制训练曲线，您将观察到误差呈线性下降，但非常缓慢。解决方法是提高学习率。
缓慢进展训练曲线
不稳定性和振荡
问题:我们看到，当学习率太小时，我们的算法进展缓慢，导致计算成本高。另一方面，如果我们将学习率设置得太高，梯度下降就会过冲。有时，随着每一步&快速放大，超调变大。这种现象被称为不稳定。在训练曲线中，你会观察到成本会突然射向无穷大。
当学习率很大，但还不足以导致不稳定时，您将获得大的权重更新。反过来，这将导致重量分散&将导致后续训练周期的振荡。
1]由于大的学习率导致的不稳定性 2]由于大的学习率导致的振荡
解决方案:如上所述，具有大的学习速率会导致不稳定或振荡。因此，第一个解决方案是通过逐渐降低学习率来调整学习率。
在振荡的情况下，另一个在不影响训练速度的同时抑制振荡的解决方案是动量。动量是我们在权重更新规则中引入的附加参数，如下所示:
动量梯度下降
这里，θ是模型参数(权重和偏差)向量，“α”是学习率，“ε”是成本，“μ”是动量。动量取值 0≤μ≤1。当μ=0 时，我们得到标准梯度下降(没有动量的梯度下降)。
动量有助于算法基于梯度的过去行为搜索最优值。除了只使用当前步骤的梯度，动量还累积过去步骤的梯度(权重更新的历史)来确定要去的方向。这导致在一个方向上的许多过去的梯度更新在将来继续在那个方向上，从而防止振荡。
局部最优
问题:在最小化代价函数时，我们有时会陷入局部最优。大多数时候，这种情况发生是因为我们陷入了糟糕的吸引盆地。导致给定局部
最优的一组权重被称为吸引域。通常，如果你处于一个糟糕的吸引盆中，就不容易诊断。
解决方案:此类问题的常见解决方法是随机重启。这里，我们从几个随机值中初始化训练，用每组值训练模型，&选择给出最低成本的值。
波动
问题:在随机梯度下降中，我们使用每个时期的单个例子来计算梯度，这使得梯度也是随机的。因此，即使这些随机梯度平均指向正确的方向，但单独来看，它们是有噪声的。该噪声在随机方向上推动模型参数，即波动模型参数&增加总成本。大多数情况下，诊断波动最简单的方法是查看成本函数&训练曲线。
解决方案:应对波动的更好方法是学习率衰减。在这种方法中，我们在训练&的大部分时间里保持相对较高的学习率，只是在接近结束时，当模型参数平均良好，但由于波动，我们的成本较高时，我们使用以下规则衰减它:
这里，α0 是初始学习速率，t 是迭代次数，τ是衰减时间尺度，t = 0 对应于衰减的开始。
应该注意的是，如果我们过早地降低学习率，我们可能会看到成本的改善，但这将导致收敛缓慢。
死单元和饱和单元
问题:饱和单元是其激活总是接近其动态范围/可能值的末端的单元。死亡单位是激活总是接近于零的单位。死&饱和单位有问题。因为这种单元接近其动态范围的末端，所以没有梯度信号会通过它们。因此，送入这种装置的所有砝码不会得到梯度信号。如果输入权重&偏差不变，则该单元可以长时间保持饱和。这种情况对应于平台。
解决方案:由于死单元和饱和单元会导致平台情况，我们可以使用类似 ReLU 的激活功能，它不会饱和。ReLU 不会因为正值而饱和，这很方便但是会因为负值而死亡。因此，用正值初始化偏差是有帮助的。
病态曲率
问题:一个条件很差的曲率即沟壑是在不同方向上曲率不同的曲面。
Rosenbrock 函数用作优化示例。蓝色区域表示峡谷或曲率条件差的区域。
在训练神经网络时，我们需要在高曲率方向上的小学习率，否则梯度可能会过冲。同样，在低曲率方向，我们需要一个大的学习率，这样我们才能快速达到最优。但是在梯度下降过程中正好相反。它倾向于在高曲率方向上迈出大步，反之亦然。我们需要学习率在高曲率方向上较小，这样我们就不会出现振荡或不稳定&同时，我们希望学习率在低曲率方向上较大，这样算法就能快速向最优方向前进。
解决方案:如前所述，我们可以用动量来解决这个问题，因为我们想防止振荡。另一个解决方案是使用亚当算法。Adam 分别调整每个参数的学习速率，以便我们沿着每个单独的方向获得正确的曲率。
希望这篇文章对你有所帮助，😄
此外，欢迎任何建议/更正。
编码快乐！！
你应该知道的 8 个常用熊猫展示选项
熊猫帮助你开始数据分析的提示和技巧
照片由维多利亚诺·伊兹奎尔多在 Unsplash 上拍摄
Pandas 是最重要的数据操作和分析库之一。它不仅提供了操作数据的数据结构和操作，而且还以漂亮的表格形式打印出结果，带有标记的行和列。
在大多数情况下，熊猫显示的默认设置应该工作良好，但您可能希望您的数据以某种格式显示，而不是默认格式。Pandas 有一个选项系统，允许你定制与显示相关的选项。可以使用方法或属性配置显示选项，如下所示:
**# Use methods**
import pandas as pdpd.set_option()
pd.get_option() **# Use attributes**, for example display max_rows
pd.option.display.max_rows
在本文中，我们将看看 8 个常用的显示选项。这篇文章的结构如下:
- 显示更多行
- 显示更多列
- 设置要显示的最大字符数
- 设置浮动列的精度
- 格式化大数字的显示
- 更改绘图后端
- 配置
info()的输出 - 重置显示选项
请查看笔记本获取源代码
为了演示，我们将使用 Kaggle 上的 Titanic 数据集。
1.显示更多行
默认情况下，Pandas 不想让你的显示溢出，如果超过了display.max_rows，它会截断中间的行。您可以通过运行以下语句来查找该值:
**pd.get_option('display.max_rows')** # pd.options.display.max_rows60
一旦超过了display.max_rows，那么display.min_rows(默认为5)选项将决定在截断的表示中显示多少行。例如，运行df，它显示前 5 行，在中间截断所有行，然后显示最后 5 行。
作者图片
例如，如果您想更改display.max_row，将其设置为 200 行:
pd.**set_option**('display.max_rows', **200**)# pd.options.display.max_rows = 200
您也可以将该值设置为None来显示所有行。但是要小心，因为如果你有一张非常长的桌子，它就不会很好地工作。
pd.**set_option**('display.max_rows', **None**)# pd.options.display.max_rows = None
要重置该值:
# To reset
pd.**reset_option**('display.max_rows')
2.显示更多列
类似地，列有一个display.max_columns选项，其值默认为20:
pd.get_option('display.max_columns')
# pd.options.display.max_columns20
作者图片
例如，如果您想要更改该值，请将其设置为 30:
pd.set_option('display.max_columns', **30**)# pd.options.display.max_columns = 30
同样，您也可以将值设置为None来显示所有列。但是要小心这一点，因为如果你有一个非常宽的桌子(有很多功能)，它不会工作得很好。
pd.set_option('display.max_columns', **None**)# pd.options.display.max_columns = None
要重置该值:
pd.**reset_option**('display.max_columns')
3.更改列宽
运行df.head()，您可能会发现第二行显示一个省略号(…)。这是因为 Pandas 对显示多少个字符有一些限制，默认值是50个字符。
作者图片
pd.**get_option('display.max_colwidth')** # pd.options.display.max_colwidth50
例如，如果您想要更改该值，请将其设置为 500 个字符:
pd.**set_option**('display.max_colwidth', **500**)# pd.options.display.max_colwidth = 500
同样，也可以将值设置为None来显示所有字符。但是要小心，因为如果你有一个非常长的文本的列，它不会工作得很好。
pd.**set_option**('display.max_colwidth', **None**)# pd.options.display.max_colwidth = None
最后，重置该值:
pd.**reset_option**('display.max_colwidth')
4.设置浮动列的精度
您可能会注意到，Pandas 对浮动列显示的小数位数也有一些限制。
作者图片
pd.get_option('**display.precision**')
# pd.options.display.precision6
默认情况下，熊猫只会显示小数点后的 6 位数字，如果它有更多的小数。
例如，如果您想要更改该值，请将其设置为两位小数:
pd.set_option(**'display.precision', 2**)# pd.options.display.precision = 2
作者图片
注意这个设置不影响底层数据，它只影响浮动列显示。
要重置该值:
pd.reset_option('**display.precision**')
5.格式化数字的显示
最好将显示格式化为数字，例如货币、小数、百分比等。Pandas 可以使用display.float_format选项格式化任何浮动列。
注意这只适用于 float 列，对于其他数据类型，您必须将它们转换成 float。如果您想了解更多有关将数据转换为浮点型的信息，可以查看:
用逗号格式化大数字
大数字，例如1200000，总是很难读懂。它
pd.set_option('display.float_format', **'{:,}'.format**)df_test
作者图片
设置十进制格式
假设我们只关注小数点后的 2 位数字，我们可以使用此选项将显示格式化如下:
pd.set_option('display.float_format', **'{:,.2f}'.format**)
df_test
作者图片
用百分号或美元符号格式化
假设我们正在显示一个百分比列，我们可以使用此选项将显示内容格式化为一个百分号:
pd.set_option('display.float_format', **'{:.2f}%'.format**)
df_test
作者图片
并用美元符号格式化
pd.set_option('display.float_format', **'${:.2f}'.format**)
df_test
作者图片
6.更改绘图后端
Pandas 在其数据帧和系列上提供绘图功能。默认情况下， matplotlib 被用作绘图后端。从版本 0.25 开始，Pandas 提供了一个使用不同后端的选项。
要将其更改为不同于默认 matplotlib 的后端，您首先需要安装第三方库，例如:
然后，只需要将plotting.backend设置为'ploty'或'altair'，就像使用第三方库一样调用绘图方法，例如:
import pandas as pd
import numpy as np
**pd.set_option('plotting.backend', '****altair****')**data = pd.Series(np.random.randn(100).cumsum())
data.plot()
重置为默认绘图后端:
pd.**reset_option**('**plotting.backend**')
7.配置info()的输出
我们大多数人都在用熊猫info()的方法快速检查数据框的轮廓。然而，该方法对要分析的最大列数有一个默认的约束，当从一个大的数据集中计算null时会非常慢。
熊猫提供了两种选择:
display.max_info_columns:默认为100，设置需要分析的最大列数。display.max_info_rows:默认为1690785，设置计数null时的阈值。
当分析具有 150 个特征的数据集时，我们可以将display.max_info_columns设置为覆盖所有列的值。例如，将其设置为 200 列:
pd.set_option('display.max_info_columns', **200**)
在分析大型数据集时，df.info()可能会非常慢，因为要对所有null进行计数。我们可以简单地将display.max_info_rows设置为一个小值，以避免对其进行计数，比如只在行数不超过 5:
pd.set_option('display.max_info_rows', **5**)
8.打印出当前设置并重置所有选项
pd.describe_option()将打印出设置的描述及其当前值。
pd.describe_option()
作者图片
你也可以用它来打印一个特定的选项，例如，行显示选项
# specific searching
pd.describe_option('rows')
作者图片
最后，您可以通过运行以下语句来重置所有选项:
pd.**reset_option('all')**
结论
在这篇文章中，我们学习了 8 个常用的熊猫显示选项，可以帮助您格式化和改善您的熊猫输出。
希望这篇文章能帮助你节省和熊猫学习数据分析的时间。我建议你查看一下关于熊猫选项&设置的文档，并了解你可以做的其他事情。
感谢阅读。请查看笔记本获取源代码，如果你对机器学习的实用方面感兴趣，请继续关注。
你可能会对我的其他一些熊猫文章感兴趣:
- 熊猫将数字和字符串转换成日期时间的 10 个技巧
- 所有熊猫 json_normalize()你应该知道的扁平化 JSON
- 使用熊猫方法链接提高代码可读性
- 如何对熊猫数据帧进行自定义排序
- 为了数据分析你应该知道的所有熊猫移位()
- 何时使用 Pandas transform()函数
- 你应该知道的熊猫串联()招数
- Pandas 中 apply()和 transform()的区别
- 所有的熊猫合并了()你应该知道
- 在 Pandas 数据帧中处理日期时间
- 熊猫阅读 _csv()你应该知道的招数
- 你应该知道的用 Pandas read_csv() 解析日期列的 4 个技巧
更多教程可以在我的 Github 上找到
2021 年 Kaggle 的 8 个数据科学项目创意
蒂娜·万霍夫在 Unsplash 上的照片
最后，我们来到了 2021 年🎉
这是人生的新篇章🐣
对我来说，作为一名数据科学家，我想利用这个机会总结一份我在 2021 年在 Kaggle 上发现的有趣数据集的列表。我也希望这个列表可以对那些正在寻找数据科学项目来建立自己的投资组合的人有用。
动机
在尝试了许多不同的途径来学习数据科学之后，我发现迄今为止最有效的途径是从真实数据集着手进行项目。然而，这听起来很简单，但实际上从零开始构建数据科学投资组合非常具有挑战性。
数据科学是一门宽泛的学科。即使有这么多免费的在线资源，新手也很容易感到迷失。被动地学习新概念并不能保证你下次面对类似的问题时能够解决。
最后，我觉得设计自己的学习地图的能力很重要，以确保你处于主动学习模式。它需要你的热情、逻辑、勤奋和对数据科学的全面理解。
要成为一名积极的学习者，在任何科目中，兴趣是你最好的老师。😼
因此，我总结了一些最近从 Kaggle 更新的数据集。这些任务从情感分析到建立预测器不等。我也尝试增加一些延伸阅读，作为更多探索的选择。
(我根据日期和投票选择了数据集。)
项目创意
人力资源分析:
https://www.kaggle.com/arashnic/hr-analytics-job-change-of-data-scientists
- 预测候选人为公司工作的可能性。
- 解释模型，说明哪些特征影响候选人决策。
数据集不平衡。需要一些策略来修复不平衡的数据集。
疫苗推文:
https://www.kaggle.com/gpreda/pfizer-vaccine-tweets
- 浏览关于辉瑞和 BioNTech 新疫苗的推文，了解公众的反应、讨论的话题以及与疫苗相关的积极和消极情绪。
我们可以通过使用拥抱脸包来简化 NLP 过程。
https://github.com/huggingface/transformers
信用卡客户:
https://www.kaggle.com/sakshigoyal7/credit-card-customers
- 提高预测流失客户的绩效。
- 想象一下频繁客户和不频繁客户之间的区别。
一个很好的数据集来理解精度和召回。
在这个商业问题中，最重要的是识别那些被搅动的顾客。即使我们预测不活跃的客户会变得活跃，这也不会损害我们的业务。但是预测客户变得不活跃就可以了。所以召回率(TP/TP+FN)需要更高。
Spotify 音乐数据集:
https://www.kaggle.com/yamaerenay/spotify-dataset-19212020-160k-tracks
- 分析一个世纪以来歌曲的发展趋势。
- 建立一个基于内容的推荐引擎，推荐艺术家。
- 寻找不同流派中有影响力的艺术家。
- 基于其他特征预测歌曲流行度。
- 根据音频特征将不同的流派进行分类。
这是一个很有潜力的数据集。如任务中所列，该数据集适用于推荐引擎、趋势分析、流行度预测器和无监督聚类。
美国大选:
https://www.kaggle.com/manchunhui/us-election-2020-tweets
- 对两位总统候选人的推文进行情感分析。
虽然这个任务要求我们执行情感分析，但我觉得基于文本数据构建词云也是合适的。
比特币价格:
https://www.kaggle.com/mczielinski/bitcoin-historical-data
- 从历史数据预测比特币价格。
这可以是一个时间序列分析任务。
Yelp:
https://www.kaggle.com/yelp-dataset/yelp-dataset
- 建立餐厅推荐模型。
- 对 Yelp 评论进行情感分析。
- 根据评论，预测餐厅评级。
对于餐馆推荐，热图也可能有所帮助。
Airbnb:
https://www.kaggle.com/dgomonov/new-york-city-airbnb-open-data
- 预测纽约 Airbnb 租赁价格。
- 通过查看纽约市地图上的 Airbnb 来比较不同地区的价格。
- 按房型分析价格是否有差异。
我可能想把重点放在这个经典项目的一些创造性的数据可视化上。
https://medium.com/mobgen/airbnb-and-house-prices-in-amsterdam-part-1-9dc0cbffc136 https://medium.com/typeme/lets-code-a-neural-network-from-scratch-part-2-87e209661638
结论
当我把上述资源总结成一个阅读清单时，我真的很享受自己的学习。有些项目可能具有挑战性，但努力总会有回报。对我来说，一个困难的项目想法比一个简单的想法让我更愿意学习。同时，一个复杂的数据集通常包含更多的特征，使我们能够深入地完成一个项目。
努力总会有回报的。🏆
我希望你在这篇文章中找到一些真正让你感兴趣的项目想法！
新年快乐
快乐学习
下次见
2022 年的 8 个数据科学边项目
在 2022 年，将提升你的数据科学技能的边项目的独特想法
随着 2022 年的临近，你正在制定你的新年计划，看看这个数据科学附带项目的列表，并获得灵感，在明年做一些有意义的事情。发展一项新技能，重温旧技能，或者只是获得额外的收入来源。无论是什么驱动你，正确的项目真的可以让你一年。
创建体育博彩情报服务
“体育博彩小费服务”是一种出售体育博彩小费的服务。如果你能定期向人们提供关于下一场足球比赛的深刻见解，他们会愿意花大价钱。
好吧，但是这和数据科学有什么关系呢？嗯，有了正确的数据和正确的技能，你实际上就可以很好地计算许多事情的概率，包括体育赛事的结果。然后你可以把这些评估卖给那些想在网上下注的人。
实际上，这个项目最困难的部分之一是以一种自动化的方式收集可靠的数据。有几种方法可以做到这一点:从出售这类数据的网站获得付费订阅，网络搜集，或者，如果你足够幸运，找到可以公开获得并定期更新的原始数据。一旦您成功地实现了数据摄取的自动化，那么您就知道剩下的事情了:清理数据、特性工程等。，就像任何其他数据科学项目一样。
一旦你对你的结果感到满意，你可以建立一个简单的服务来出售它们:你可以出售概率或实际预测，但我更喜欢概率。
另一条建议是:试着专注于适度流行的运动。它应该足够大，你可以找到足够多的数据，你可以在上面下注，人们至少会感兴趣，但不要大到已经有很多人在上面做基于 ML 的预测。
使用 Raspberry PI 构建您自己的集群
虽然这个项目不像列表中的其他项目那样以数据为中心，但它可以带来很多乐趣，并且是提高计算机科学技能的好方法。
获得至少两台 Rasperry Pis(那些小巧廉价的计算机)，将它们连接在一起，使它们作为一个计算机集群工作，您可以使用它们进行并行计算、托管网站、本地服务器……可能性是无限的。
但是使用一些云提供商不是更简单吗？是的，但是从头构建一个集群会教会你很多关于硬件的知识，设置服务器，安装 Linux 和 Kubernetes。
这里有几个教程可以帮助你:
https://blog.alexellis.io/self-hosting-kubernetes-on-your-raspberry-pi/ https://ubuntu.com/tutorials/how-to-kubernetes-cluster-on-raspberry-pi#4-installing-microk8s
获得 GCP 专业机器学习工程师 C 认证
根据谷歌云平台的网站，“一名专业机器学习工程师设计、构建和生产 ML 模型，以利用谷歌云技术和成熟的 ML 模型和技术知识来解决业务挑战”。
这不仅是一个有价值的认证本身，而且学习它的过程将教会你很多关于机器学习的知识:哪些指标更适合每种情况，不同类型的神经网络如何工作以及如何调整它们，如何进行交叉验证等。
我在这里写了一篇如何学习的教程:
[## 我是如何通过 GCP 专业 ML 工程师认证的
towardsdatascience.com](/how-i-passed-the-gcp-professional-ml-engineer-certification-47104f40bec5)
创建 MOOC
创建一个 MOOC 起初看起来势不可挡，但如果你将项目分解成更小的目标，你实际上可以在短短几个月内完成。
你首先要决定你想教什么，和教谁。已经有很多通用机器学习、统计学等课程。这不仅是一个更艰难的努力，而且也不太可能给在线课程的前景增加新的东西。相反，试着关注一些更窄的东西，比如你使用的工具或者你日常工作中的具体用例。一旦你有了这些，你就可以写下课程内容:你要教什么，你要如何分解它。
然后，决定格式:例如，你会录下你自己说话的视频，还是只录下你的屏幕？对于新手来说，我建议后者，因为它更容易执行，也没有让你的脸出现在互联网上那么吓人。
最后，开始录音。为你每周要录制的部分制定一个时间表，并坚持下去。如果你只是记录你的屏幕和做画外音，你需要的只是一个好的麦克风和一台电脑。
到了发布的时候，你有很多选择，但是尽量坚持使用那些对初学者友好的知名平台，比如 Hotmart 和 Udemy。这一部分结束后，是时候推广你的在线课程了。这本身就是一个完整的主题，所以我们将忽略它，但是你可以在网上找到关于它的无穷无尽的内容。
向其他人解释一些东西是吸收内容的最好方法之一，所以这个项目实际上会迫使你温习你将要教授的主题。而且，还能帮你兼职赚点外快，也没那么差。
创建公共仪表板
这个项目是为那些想要提高数据可视化技能的人设计的，也是这个列表中最容易实现的:获取一些公开可用的数据，将其插入 dataviz 工具，构建一个有洞察力的仪表板，并在某个地方发布它。就这么简单。
什么数据？任何能激励你并能引起人们注意的事情。许多人对 COVID 数据都是这样做的，但是还有更多有趣的数据集(Kaggle 是一个很好的来源)。
一旦你有了数据，选择你想要的任何 dataviz 工具。就个人而言，我喜欢 Tableau，但对于一个简单的用例，Google Data Studio 可以完成这项工作，而且是免费的。
然后，你可以在 Github 或其他免费工具上托管你的仪表板，与世界分享你的精彩见解。
写一本书
现在自助出版比以前容易多了:像亚马逊这样的平台允许你以数字和印刷的方式出版你的书，并在世界范围内发行。然而，这也带来了一个诅咒:现在有更多低质量的书籍，因为一些人只是为了建立个人品牌而想出版一本书。请不要成为那样的人。只有当你真的确信你发布的内容是相关的或者在某些方面是新的时，才写一本书。并确保你知道你在说什么，并在写作前大量研究。
也就是说，一旦你心中有了一个主题和这本书的结构，就开始写作，不要害怕多次重写，直到你得到你想要的。一旦你有了第一个版本，试着与你信任的人分享，获得反馈，并改进它。
光是必要的研究就会让你成为一名更好的数据科学家，把你的知识用语言表达出来的行为会让你成为一名更好的思考者。
你可能要花一年多的时间才能完成，但你总得从某个地方开始，对吧？也许承诺在一年内完成初稿，这本身就已经是一大成就了。
为开源项目做贡献
以你喜欢的 Python 库为例，寻找改进的方法。如果你从来没有这样做过，从小处着手。
Scikit-learn 有一个关于贡献的指南，为新贡献者提供了一个特别的会议，他们列出了“好的首要问题”，你可以解决这些问题来习惯他们的贡献过程。一旦你熟悉了它，你就可以继续做更复杂的贡献了。
这可能不会让你赚钱，但回报社区总是好的，因为我们都从开源中受益。你将发展你的合作技能。
开始教学
在 COVID 让在家工作和学习更加频繁之后，在线教学的机会就多了很多，这让这个副业项目变得平易近人了很多。
有时教学的门槛会很高，所以不要只搜索大学，也要搜索有直播课的在线课程。此外，一些课程可能已经有了自己的结构化内容，这让你更容易坚持下去，而不是从头开始编写自己的内容。
教学可以在很多方面帮助你，从提高你的公共演讲技能到迫使你深入研究某一特定主题并真正理解其核心。
如果你喜欢这篇文章，你可能也会喜欢这些:
https://medium.com/curious/5-books-every-data-scientist-should-read-in-2021-206609d8593b
如果你想进一步讨论，请随时通过 LinkedIn 联系我，这将是我的荣幸(老实说)。
每个数据科学家都应该知道的 8 种降维技术
Python 中各种降维技术的基本指南
探索性数据分析是数据科学模型开发流程的重要组成部分。数据科学家将大部分时间花在数据清理、特性工程和执行其他数据争论技术上。降维是数据科学家在执行特征工程时使用的技术之一。
降维是将高维数据集转换到可比较的低维空间的过程。真实世界的数据集通常有许多冗余要素。降维技术可用于去除这种冗余特征或将 n 维数据集转换成 2 维或 3 维以便可视化。
在本文中，我们将讨论 8 种这样的降维技术，它们可用于各种用例来降低数据集的维度。
***Checklist:***
**1\. Missing Value
2\. Correlation Filter
3\. Variance Filter
4\. Forward / Backward Feature Selection Techniques
5\. PCA (Principal Component Analysis)
6\. t-SNE (t-distributed Stochastic Neighbourhood Embedding)
7\. UMAP
8\. Auto-Encoders**
(1.)缺少值:
真实世界的数据集通常包含大量缺失记录，这可能是由于数据损坏或记录数据时出现故障造成的。人们可以尝试各种数据插补技术来填补缺失的记录，但这只适用于某个特征缺失有限数量的记录的情况。
如果缺失特征值的数量大于确定的阈值，则最好从训练数据中移除该特征。可以移除缺失特征记录大于阈值(比如 50%)的所有特征，从而降低数据的维度。
(图片由作者提供)，缺失值的可视化:白线表示缺失值的存在
使用[**missingno**](https://github.com/ResidentMario/missingno)包为钛数据生成上述缺失值解释图像。特征“年龄”和“船舱”具有大量缺失记录，最终，它们可以从训练样本中移除。
(2.)相关滤波器:
一个或多个要素的相关性可能会导致多重共线性问题。要素的多重共线性会破坏独立变量的统计显著性。想法是丢弃与其他独立特征相关的特征。还可以删除与目标类别标签不相关的特征。
有各种技术来计算独立特征之间的相关性，包括 Pearson、Spearman、Kendall、卡方检验等。
(图片由作者提供)，相关矩阵的热图
使用**df.corr()** 函数计算上述关联矩阵的热图(针对泰坦尼克号数据集)。
(3.)方差过滤器:
只有一个特征类别的分类特征或具有非常低方差的数字特征变量可以从训练样本中排除。这些特征可能对模型训练没有帮助。
函数**DataFrame.var()**可以计算熊猫数据框所有特征的方差。**DataFrame.value_counts()**函数可以计算每个特征的分布。
(4.)向前/向后特征选择:
前向特征选择技术是选择最佳特征集的包装器技术。这是一个循序渐进的过程，基于上一步的推断选择特征。正向特征选择技术的步骤是:
- 分别使用每个 d 特征训练机器学习模型，并测量每个模型的性能。
- 采用具有最佳性能的特征，并使用其余特征重新训练单个模型。
- 使用我们获得最佳性能的功能与上一步中的功能列表连接在一起。
- 重复步骤 2 和 3，直到获得所需数量的特征。
(源)，正向特征选择
后向特征选择技术类似于前向特征选择，但是工作方式正好相反，最初选择所有特征，并且在每一步中移除最冗余的特征。
(5.)主成分分析:
主成分分析(PCA)是一种非常古老的降维技术。PCA 通过保持特征的方差将特征向量投影到低维空间。它寻找最大方差的方向以获得最佳特征列表。
PCA 可以用于将非常高维的数据投影到期望的维度中。PCA 算法的步骤是:
- 列标准化数据集
- 计算标准化数据集的协方差矩阵
- 从协方差矩阵计算特征值和特征向量
- 取特征向量与具有高特征值的特征向量的点积。
Scikit-learn 包附带了 PCA 的实现，请阅读文档以了解有关实现的更多信息。
请阅读我之前发表的文章，了解 PCA 如何提高分类模型的性能
(6.)t-SNE:
t-SNE(t-分布式随机邻域嵌入)是一种降维技术，主要用于数据可视化。t-SNE 将高维数据集转换成可以进一步可视化的 2 或 3 维向量。
t-SNE 比 PCA 性能更好，因为它保留了数据的局部结构，并通过保留邻域局部结构将每个数据点从高维空间嵌入到低维空间。
Scikit-learn 包附带了 t-SNE 的实现，阅读文档了解更多关于实现的信息。
阅读下面提到的来自distilt . pub的文章，了解如何有效地使用 t-SNE:
https://distill.pub/2016/misread-tsne/
(7.)UMAP:
UMAP(均匀流形逼近)是一种降维技术，其工作原理类似于 t-SNE，通过将高维数据集投影到可比较的低维空间。
UMAP 在数据的原始空间中构建了一个邻居图，并试图在更低维度中找到一个相似的图。
阅读 Scikit documentaion 的下述文章，了解如何有效地使用 UMAP:
https://umap-learn.readthedocs.io/en/latest/basic_usage.html
(9.)自动编码器:
自动编码器是一种基于单层感知器的降维方法。它有两个组成部分:压缩(编码器)和扩展(解码器)。输入和输出层中的节点数量是相同的，而中间层与输入和输出层相比具有较少的神经元。
(图像源)，自动编码器架构
数据集被传递到自动编码器神经网络模型，并被编码到较低维度的隐藏层。然后，它尝试从简化的编码中生成，以获得尽可能接近其原始输入的表示。中间层是降低到相当低的维度的向量。
结论:
在本文中，我们讨论了基于特征选择的降维方法、基于组件的降维技术、基于投影的方法，最后讨论了基于神经网络的自动编码器。
ISOMAP 是另一种基于投影的降维方法，其工作原理类似于 UMAP 和 t-SNE。SVD 和 ISO 是其他一些基于组件的降维技术。
参考资料:
[1] Scikit-learn 文档:https://sci kit-learn . org/stable/modules/unsupervised _ reduction . html
感谢您的阅读
开始使用 Conda 环境的 8 个基本命令
开始为所有数据科学项目使用环境
本杰明·格兰特在 Unsplash 上拍摄的照片
介绍
对于 Python 初学者来说，虚拟环境不是最直接的概念。当我们安装软件时，比如微软 Office 和 Evernote，我们大多数人都习惯于应用默认配置，这包括为你电脑上的所有用户安装软件。换句话说，软件被安装在系统级，使得不同的用户之间只共享软件的一个副本。
这是我们大多数人多年来养成的习惯。我们在开始学习 Python 的时候就养成了这个习惯。我们在电脑上安装了 Python，学会了直接给系统安装各种 Python 包。随着 Python 在我们工作中的使用越来越多，当事情开始变得混乱时，我们有机会为不同的工作任务使用不同的包。
软件包 A 依赖于版本为 2.0 的软件包 B，所以当我们在系统级安装软件包 A 时，软件包 B 2.0 也会在系统级安装。然而，我们的另一个项目需要包 C，它依赖于版本为 2.5 的包 B。如果我们安装软件包 C，我们的系统会将软件包 B 更新到版本 2.5，以满足软件包 C 的要求。不幸的是，软件包 A 尚未更新到与软件包 B 2.5 兼容，因此我们在使用软件包 A 时会遇到问题。
这只是许多初学者在学习 Python 的过程中迟早会遇到的一个常见问题。除了这些包依赖冲突之外，还有一些项目需要不同版本的 Python。例如，可能一些遗留项目仍然使用 Python 2.x，而大多数项目使用 Python 3.x。即使对于那些使用 Python 3.x 的项目，一些项目可能工作到 Python 3.4，而另一些项目需要 Python 3.5 以上。因此，如果 Python 只安装在所有项目的系统级，Python 版本冲突可能是另一个问题。
康达环境来拯救。Conda 是一个全面的包和环境管理工具，尤其适用于数据科学家。最重要的是，conda 还优化了数据科学相关的库，如 NumPy、SciPy 和 TensorFlow，这些库最大限度地提高了可用硬件的性能，以获得最佳的计算能力(更多介绍可在 conda 的网站上找到)。使用 conda 工具，我们为我们的项目创建隔离的环境，这些项目可以有不同的包，甚至不同的 Python 版本。
如果你的电脑上还没有安装康达，可以参考官网了解详细的安装说明。conda 有两个版本:Miniconda 和 Anaconda，前者提供 conda 及其依赖项，因此更加紧凑，而后者提供更多科学研究所需的包。一旦安装了 conda，您应该能够在终端(或者您选择的其他命令工具)中运行下面的命令。
conda --version
提示符将显示您计算机上安装的 conda 版本。这样的话，你可以走了。让我们探索一下在大多数情况下管理环境时应该知道的最基本的命令。
1.检查可用环境
让我们先做一个清单检查，看看有哪些可用的环境。运行以下命令。
conda env list
假设您刚刚安装了 conda，您可能会看到以下内容。
# conda environments:
#
base * /opt/anaconda3
base是 conda 在安装过程中为我们创建的默认环境。- 星号表示该特定环境是活动环境。
- 该路径显示了环境及其相关包的物理目录。
当我们想要对我们的计算机上的 conda 环境有一个总的了解时，这个清单检查命令是有用的。
2.创建新环境
要创建新环境，请运行以下命令。
conda create --name firstenv
- 标志
--name表示我们将要指定新环境的名称。在这种情况下，新创建的环境将被命名为firstenv。 - 作为一种快捷方式，你可以用
-n代替--name。
当 conda 为您创建环境时，可以扩展这个基本命令来安装额外的包。例如，以下命令将为您安装 numpy 和请求。
conda create -name firstenv numpy requests
此外，我们甚至可以指定这些包的特定版本，如下所示。
conda create -n firstenv numpy=1.19.2 requests=2.23.0
安装完成后，您可以通过运行conda env list来验证环境是否已经成功创建，这将向您显示firstenv在列表中。
如果您知道环境需要哪些包，那么您可能希望在创建环境时安装所有的包，因为单独的安装可能会导致依赖冲突。当它们全部安装在一起时，任何潜在的冲突都会得到解决。
3.激活环境
一旦创建了环境，就该“进入”环境了。用一个更标准的术语来说，这叫激活环境。运行以下代码。
conda activate firstenv
一旦您运行了这个，您应该会注意到，如果您选择了不同的名称，提示前面会加上(firstenv)或(your-own-env-name)，如下所示。
(firstenv) your-computer-name:directory-path your-username$
由于firstenv被激活，出于好奇，你可以再次运行conda env list。你会发现星号会出现在firstenv环境的行中。
# conda environments:
#
base /opt/anaconda3
firstenv * /opt/anaconda3/envs/firstenv
4.安装、更新和卸载软件包
由于环境已经安装，您意识到您想要安装额外的软件包，而您在创建环境时忘记了指定这些软件包。根据软件包的可用性，有几种安装软件包的方法。
您可以首先尝试运行以下命令，该命令将尝试从默认通道 anaconda 安装软件包。顺便说一下，如果需要，可以在包名后面指定版本。
conda install pandas
但是，默认的 anaconda 通道可能没有特定的包。在这种情况下，您可以尝试另一个名为conda-forge的公共通道，如下所示。--channel或简称为-c表示获取包的通道。
conda install -c conda-forge opencv
Python 包的另一个重要渠道是众所周知的 Python 包索引，通过 Python 包管理工具pip。它由 conda 原生支持。下面是一个简单的例子。
pip install pandas
尽管有多个渠道可以安装相同的包，但还是建议您尽可能多地从 anaconda 获得它们，因为它们可能已经过优化以获得更好的性能。另外，要了解更多的渠道，可以参考网站。
要更新软件包，根据安装通道，您可以简单地用update命令替换install。
要卸载这个包，我们将使用uninstall命令，如下所示。需要注意的是，该命令是remove的别名(如conda remove pandas)。
conda uninstall pandas
5.检查已安装的软件包
当您在您的环境中工作时，您安装了越来越多的包，在某些时候，您可能想要检查已经安装了哪些包。为此，请运行以下命令。
conda list
您可能会看到如下所示的内容。
已安装的软件包
值得注意的一点是，列表会显示软件包是从哪个通道安装的。在这种情况下，我们有来自 pypi 和 conda-forge 的包。当没有通道信息时，这意味着软件包是从默认通道(anaconda)安装的。
如果您认为列表太长而无法识别某个特定的包，您可以通过运行下面的命令来检查单个包的信息。
conda list opencv
6.停用环境
如果你完成了工作，你就准备离开当前的环境。在虚拟环境术语中，它被称为停用环境。为此，请运行以下命令。
conda deactivate
运行这个命令后，您会注意到前缀(firstenv)从命令行的提示中删除了。如果感兴趣，您可以运行conda env list来查看活动星号是否不再与firstenv环境相关联。
7.共享环境
可再现性是 conda 和任何其他环境管理工具想要实现的一个关键目标，这样在您的计算机上运行的代码也可以在您的队友的计算机上运行，而不会出现任何问题。因此，我们可以在不同的计算机上重建相同的环境，这一点很重要。有几个命令对共享环境很有用。
进入虚拟环境后，运行下面的命令。
conda env export > environment.yml
该命令将在您的当前目录中创建一个需求文件，该文件列出了当前环境的信息，例如名称、依赖项和安装通道。你可以打开文件看一看，这只是一个文本文件。
你与那些想要重现这种环境的人分享这个文件。要使用该文件重建环境，只需运行下面的命令。如果需要，可以编辑yml文件使其工作，比如更改环境的名称。
conda env create -f environment.yml
-f标志表示我们想要从指定的文件中创建一个环境。如果您已经导航到environment.yml所在的目录，您可以简单地运行conda env create。
8.移除环境
当我们需要删除不再使用的环境时，运行以下命令。
conda remove -n firstenv --all
-n标志指定环境的名称。-all标志指定这个环境中的所有包都将被删除。这意味着环境也将被移除。
运行该命令后，出于好奇，您可以运行conda env list来检查环境是否已被成功移除。
结论
在本文中，我们回顾了 8 个基本的 conda 命令(从技术上讲，提到了 8 个以上)。我希望它们能对您开始使用 conda 来管理数据科学项目的环境有所帮助。这里有一个快速回顾，突出了关键点。
- 为每个项目创建一个新环境。不要担心耗尽您的磁盘空间，因为环境不会占用太多空间。
- 在创建环境时安装尽可能多的包，因为任何潜在的依赖冲突都将被处理。
- 如果 anaconda 没有您需要的包，请使用其他渠道。但是，请始终将 anaconda 视为优先通道。
- 考虑共享环境，以使用相同的包再现环境。
查询 NoSQL 数据库的 8 个示例
MongoDB 实用指南
NoSQL 指的是非 SQL 或非关系数据库设计。它提供了一种有组织的方式来存储数据，但不是以表格的形式(即标记的行和列)。
NoSQL 数据库存储数据的常用结构是键值对、宽列、图形或文档。数据科学生态系统中使用了几个 NoSQL 数据库。在本文中，我们将使用其中一个流行的 MongoDB。
MongoDB 将数据存储为文档。MongoDB 中的文档由字段-值对组成。文档被组织在一个称为集合的结构中。打个比方，文档可以看作是表中的一行，集合可以看作是整个表。如果您是 NoSQL 或 MongoDB 的新手，这里有一篇介绍性文章可以让您兴奋起来:
我们将通过 10 个例子来演示如何从 MongoDB 数据库中检索数据。
我们有一个名为“客户”的集合。客户集合中的文档包含客户姓名、年龄、性别和最后一次购买的金额。
以下是客户集合中的一个文档:
{
"_id" : ObjectId("600c1806289947de938c68ea"),
"name" : "John",
"age" : 32,
"gender" : "male",
"amount" : 32
}
文档以 JSON 格式显示。
示例 1
查询属于特定客户的文档。
我们使用 find 方法从 MongoDB 数据库中查询文档。如果不使用任何参数或集合，find 方法将检索所有文档。
我们希望看到文档属于客户 John，因此需要在 find 方法中指定 name 字段。
> db.customer.find( {name: "John"} ){ "_id" : ObjectId("600c1806289947de938c68ea"), "name" : "John", "age" : 32, "gender" : "male", "amount" : 32 }
我们可以附上漂亮的方法，使文件看起来更有吸引力。
> db.customer.find( {name: "John"} ).pretty(){
"_id" : ObjectId("600c1806289947de938c68ea"),
"name" : "John",
"age" : 32,
"gender" : "male",
"amount" : 32
}
现在读起来更容易了。
示例 2
查询属于 40 岁以上客户的文档。
使用逻辑运算符将该条件应用于年龄字段。“$gt”代表“大于”,用法如下。
> db.customer.find( {age: {$gt:40}} ).pretty(){
"_id" : ObjectId("600c19d2289947de938c68ee"),
"name" : "Jenny",
"age" : 42,
"gender" : "female",
"amount" : 36
}
示例 3
查询属于 25 岁以下女性客户的文档。
这个例子就像是前面两个例子的结合。这两个条件都必须满足，所以我们使用“与”逻辑来组合这两个条件。这可以通过用逗号分隔两个条件来完成。
> db.customer.find( {gender: "female", age: {$lt:25}} ).pretty(){
"_id" : ObjectId("600c19d2289947de938c68f0"),
"name" : "Samantha",
"age" : 21,
"gender" : "female",
"amount" : 41
}{
"_id" : ObjectId("600c19d2289947de938c68f1"),
"name" : "Laura",
"age" : 24,
"gender" : "female",
"amount" : 51
}
“$lt”代表“小于”。
实例 4
在这个例子中，我们将以不同的方式重复前面的例子。多个条件也可以用“与”逻辑组合，如下所示。
> db.customer.find( {$and :[ {gender: "female", age: {$lt:25}} ]} ).pretty()
用于组合条件的逻辑在开始处被指出。剩下的部分和前面的例子一样，但是我们需要把条件放在一个列表中([ ])。
实例 5
查询 25 岁以下的男性客户。
此示例需要一个带有“或”逻辑的复合查询。我们只需要把“\(和”改成“\)或”。
> db.customer.find( { $or: [ {gender: "male"}, {age: {$lt: 22}} ] }){ "_id" : ObjectId("600c1806289947de938c68ea"), "name" : "John", "age" : 32, "gender" : "male", "amount" : 32 }{ "_id" : ObjectId("600c19d2289947de938c68ed"), "name" : "Martin", "age" : 28, "gender" : "male", "amount" : 49 }{ "_id" : ObjectId("600c19d2289947de938c68ef"), "name" : "Mike", "age" : 29, "gender" : "male", "amount" : 22 }{ "_id" : ObjectId("600c19d2289947de938c68f0"), "name" : "Samantha", "age" : 21, "gender" : "female", "amount" : 41 }
实例 6
MongoDB 允许在从数据库中检索时聚合值。例如，我们可以计算男性和女性的总购买量。使用 aggregate 方法代替 find 方法。
> db.customer.aggregate([
... { $group: {_id: "$gender", total: {$sum: "$amount"} } }
... ]){ "_id" : "female", "total" : 198 }
{ "_id" : "male", "total" : 103 }
我们来详细说明一下语法。我们首先通过选择“\(gender”作为 id，按照性别列对文档进行分组。下一部分指定了聚合函数(在我们的例子中是“\)sum ”)和要聚合的列。
如果您熟悉 Pandas，语法与 groupby 函数非常相似。
例 7
让我们把前面的例子更进一步，添加一个条件。因此，我们首先选择“匹配”一个条件的文档并应用聚合。
以下查询是一个聚合管道，它首先选择 25 岁以上的客户，并计算男性和女性的平均购买量。
> db.customer.aggregate([
... { $match: { age: {$gt:25} } },
... { $group: { _id: "$gender", avg: {$avg: "$amount"} } }
... ]){ "_id" : "female", "avg" : 35.33 }
{ "_id" : "male", "avg" : 34.33 }
实施例 8
上例中的查询只包含两个组，因此没有必要对结果进行排序。然而，我们可能有返回几个值的查询。在这种情况下，对结果进行排序是一种很好的做法。
我们可以按照平均金额以升序对之前查询的结果进行排序。
> db.customer.aggregate([
... { $match: { age: {$gt:25} } },
... { $group: { _id: "$gender", avg: {$avg: "$amount"} } },
... { $sort: {avg: 1} }
... ]){ "_id" : "male", "avg" : 34.33 }
{ "_id" : "female", "avg" : 35.33 }
我们刚刚在聚合管道中添加了“$sort”。用于排序的字段与排序行为一起指定。1 表示升序，-1 表示降序。
结论
SQL 和 NoSQL 在数据科学生态系统中都至关重要。数据科学的燃料是数据，因此一切都始于正确、维护良好且易于访问的数据。SQL 和 NoSQL 都是这些过程的关键角色。
我们已经简要介绍了查询 MongoDB 数据库。当然，还有更多的内容需要讨论。我们可能会为一个典型的任务编写更高级的查询。然而，一旦您熟悉了基础知识，您就可以轻松地进入更高级的查询。
请继续关注更多关于 SQL 和 NoSQL 数据库的文章。感谢您的阅读。如果您有任何反馈，请告诉我。
生命科学和生物技术中机器学习应用的 8 个激动人心的案例研究
与科技行业一样激动人心和成功的行业
来自 Pexels 的 Artem Podrez 摄影
新冠肺炎让我们把注意力和希望放在生命科学和生物技术产业上。
健康是我们最宝贵的资产，我们会不惜代价保持健康。因此，生命科学和生物技术产业是巨大的，非常多样化，有许多子行业。最著名的领域是药物发现和制造、治疗学、诊断学、治疗学、基因组学和蛋白质组学、兽医生命科学，还有化妆品、医疗技术和分销。
这个行业固有大量的数据。数据可以从临床试验、药物、疗法、诊断、基因组学、医疗保健提供商那里获得，随着所有可穿戴设备的兴起，所有的个人健康数据都可以获得。
生命科学和生物技术在许多领域都是大数据产业。
另一方面，开发新疗法、药物或疫苗的成本从近 10 亿美元开始，罕见疾病的成本从两位数的 10 亿美元开始。相比之下，BioNTech 和 Moderna，每家公司都获得了近 10 亿美元的疫苗开发外部资金。总开发成本并未公开，但被认为是其倍数。
这是一笔巨大的投资，该行业尽一切努力降低成本和费用，并使治疗和疗法更快可用。因此，这个行业变得像科技行业一样由数据驱动。
因此，生命科学和生物技术行业是数据科学家的天堂。玩家拥有大量数据，一名数据科学家每天都在大数据领域工作。
很多数据科学家对这个行业并不熟悉。一个入门障碍是理解主题和从事相应领域工作所需的非常专业的知识。
第二，因果关系和精确性是最重要的，并且需要大量深入的数学和(生物)统计背景。如果一个算法导致向一家大型科技公司的服务用户显示错误的广告，什么也不会发生。如果一个算法导致药物开发中的错误决策，它可能导致投资的巨大损失，甚至导致一个人死亡。
我在生命科学和生物技术行业做了多年的数据科学顾问。我喜欢它，因为在那里我总是有最复杂和令人兴奋的问题要解决。
为了深入了解这个令人兴奋的行业，我展示了 8 个真实世界的数据科学用例。这给你一个应用程序的印象，并使你熟悉该领域的基本业务知识。
制药、生命科学和生物技术领域缺乏数据科学家。最终，我可以激励你进入这个令人兴奋的行业，工资水平和科技行业一样高，但更能抵御经济衰退。
1。 微生物组疗法的发展
我们体内有大量的微生物，即所谓的微生物群，如细菌、真菌、病毒和其他单细胞生物。微生物群的所有基因被称为微生物组。这些基因的数量是数万亿，例如，人体内的细菌比人类多 100 多倍的独特基因。
微生物群对人类健康有着巨大的影响，失衡导致了许多疾病，如帕金森病或炎症性肠病。还有一种假设是，这种失衡会导致几种自身免疫性疾病。因此，微生物组研究是一个非常热门的研究领域。
为了影响微生物群并开发微生物群疗法来逆转疾病，人们需要了解微生物群的基因及其对我们身体的影响。随着今天所有的基因测序的可能性，万亿字节的数据是可用的，但还没有探索。
为了开发针对微生物组的治疗方法并预测微生物组-药物相互作用，首先需要了解这种相互依赖性。这就是机器学习的用武之地。
第一步是找到模式。一个例子是导致运动神经元疾病的肠道微生物群失衡，即破坏骨骼肌活动细胞的疾病，即肌肉不再受控制。通常包含 1000 人以上的个人参数。监督 ML 和强化学习是该步骤中的主要算法。
人们必须考虑数百种因素，如剂型、药物溶解度、药物稳定性、给药和生产，以设计治疗方法。例如，随机森林经常用于围绕药物稳定性的问题。
最后一步是个性化治疗。为此，我们需要预测微生物群和药物的反应和相互作用。监督学习算法之后的主成分分析是标准技术。这一步最大的挑战仍然是缺乏大型数据库来训练模型。
2。 精准治风湿性关节炎的重磅炸弹
重磅炸弹是一种非常受欢迎的药物，每年至少产生超过 10 亿美元的收入。大片关注常见疾病，如糖尿病、高血压、常见癌症类型或哮喘。市场上通常有许多竞争产品。
“精准医疗”是指针对具有某些共同特征的人群的治疗方法，这些人群对特定的治疗方法有反应(见下图)。
为了更好地(即区别于其他药物)，并且为了产品的更具体的目标和营销，确定了在其疾病抑制方面反应较好的患者群体。目标和每个营销分析项目是一样的。使用的数据是所谓的真实世界数据(RWD)，即接受治疗的患者的数据，而不是来自临床试验的数据。
主要的方法是监督学习方法，因为我们有一个期望的输出值。除了回归/逻辑回归、支持向量机和随机森林的常用方法之外，今天，随着数据量的增加，还应用了像卷积神经网络(CNN)这样的深度学习算法。CNN 经常胜过其他方法。
作者提供的图片
3。 手机健康预测心力衰竭
心力衰竭通常会导致急诊或住院。随着人口老龄化，心力衰竭在人口中的比例预计会增加。
患有心力衰竭的人通常已经存在疾病。因此，远程医疗系统用于监控和咨询患者，以及收集和传输移动健康数据(如血压、体重或心率)的情况并不少见。
大多数预测和预防系统都是基于固定的规则，例如，当特定的测量值超过预定的阈值时，就向患者发出警报。不言自明的是，这种预测系统具有大量的错误警报，即错误肯定。
因为警报通常会导致住院，过多的错误警报会导致医疗成本增加，并降低患者对预测的信心。最终，她或他会停止遵循医疗帮助的建议。
因此，基于患者的基线数据，如年龄、性别、是否吸烟、是否使用起搏器，以及血液中钠、钾或血红蛋白浓度的测量值，以及监测的特征，如心率、体重、(收缩压和舒张压)，或关于健康或身体活动的问卷答案，最终开发出了基于朴素贝叶斯的分类器。
错误警报减少了 73%，AUC(曲线下面积)约为 70%。
4。 精神疾病的预测、诊断和治疗
据估计，全球人口中至少有 10%的人患有精神疾病。精神疾病造成的经济损失总计近 10 万亿美元。精神障碍包括焦虑、抑郁、物质使用障碍，例如阿片类、双相性精神障碍、精神分裂症或进食障碍。
因此，尽早发现精神障碍并进行干预至关重要。有两种主要方法:为消费者提供的检测疾病的应用程序和为精神病医生提供的支持诊断的工具。
面向消费者的应用通常是用机器学习算法增强的对话聊天机器人。该应用程序分析消费者的口语，并给出帮助建议。由于建议必须基于科学证据，因此必须尽可能准确地预测建议的交互和响应以及个人语言模式。
采用的方法各不相同。第一步几乎总是情感分析。在更简单的模型中，使用随机森林和朴素贝叶斯。这些模型被多达三个隐藏层的神经网络大大超越。
作者提供的图片
5。 中风生物标志物的研究发表和数据库扫描
中风是导致残疾和死亡的主要原因之一。成年人一生中患一次中风的风险约为 25%。但是中风是一种非常复杂的疾病。因此，个性化的中风前和中风后护理对治愈的成功至关重要。
为了确定这种个性化护理，应该选择人的表型，即人的可观察特征。这通常是通过生物标志物来实现的。所谓的生物标记是可测量的数据点，从而可以对患者进行分层。例如疾病严重程度评分、生活方式特征或基因组特性。
有许多已知的生物标志物已经发表或在数据库中。此外，每天都有数百篇关于检测所有不同疾病的生物标志物的科学出版物。
预防疾病的研究非常昂贵且时间紧迫。因此，生物技术公司需要了解针对特定疾病的最有效和最高效的相应生物标志物。信息量如此之大，以至于无法手动完成。
数据科学有助于开发复杂的 NLP 算法，以在数据库和出版物中找到相关的生物标记。除了了解这种生物标志物是否与特定类型的中风相关之外，还必须判断已发表结果的质量。总的来说，这是一项非常复杂的任务。
6。 3D 生物打印
生物打印是生物技术领域的另一个热门话题。基于数字蓝图，打印机使用细胞和天然或合成生物材料——也称为生物链接——来逐层打印皮肤、器官、血管或骨骼等活组织。
与其依赖器官捐赠，还不如用打印机生产，这样更符合伦理，也更划算。此外，与动物或人体试验相比，药物试验是在合成组织上进行的。由于其高度复杂性，整个技术仍处于早期成熟阶段。应对印刷复杂性的最重要的部分之一是数据科学。
打印过程和质量取决于许多因素，如具有固有可变性的生物链接的属性，或各种打印参数。例如，为了提高获得可用输出的成功率，从而优化打印过程，应用了贝叶斯优化。
印刷速度是这一过程中的关键因素。部署暹罗网络模型以确定最佳速度。为了检测材料，即组织缺陷，卷积神经网络被应用于来自逐层组织的图像。
在前期制作、制作和后期制作过程中还有更多应用，但这三个示例已经显示了所需的复杂性和高级模型。在我看来，对于数据科学家来说，这个领域是生物技术中最令人兴奋的领域之一。
7。 卵巢癌治疗中的个性化疗法
“个性化”是指应用与单个个体需求相匹配的治疗(见上图)。医疗越来越基于患者的个性化特征。
这些属性是疾病亚型、个人患者风险、健康预后以及分子和行为生物标记。我们在上面已经看到，生物标记是任何可测量的数据点，从而可以对患者进行分层。基于该数据，确定单个患者的最佳个体化治疗。
对于一名卵巢癌患者，常规化疗无效。因此，有人决定进行基因组测序，以找到导致这种癌症的错放的核苷酸碱基。通过大数据分析，人们在人类的 30 亿个碱基对中发现了这种改变，这相当于哈利波特的“魔法石”的 7798 本书的字数。
应用的方法通常是所谓的协方差模型，通常与随机森林等分类器结合使用。有趣的是，这种改变是从肺癌中得知的，肺癌中存在一种药物，但卵巢癌中没有。因此，对肺癌进行了治疗，病人康复了。
作者提供的图片
8。 供应链优化
药物的生产需要时间，尤其是今天基于特定物质和生产方法的高科技治愈。此外，整个过程被分解成许多不同的步骤，其中一些被外包给专业供应商。
我们在新冠肺炎疫苗生产中看到了这一点。疫苗发明者交付蓝图，生产在专门从事无菌生产的公司的工厂里进行。疫苗被装在罐子里送到在临床条件下进行小剂量灌装的公司，最后由另一家公司进行供应。
此外，药物只能储存有限的时间，并且通常在特殊的储存条件下，例如在冷藏室中。
从在正确的时间获得正确的输入物质，到拥有足够的生产能力，最后到为满足需求而储存适当数量的药物，整个计划是一个高度复杂的系统。这必须针对成百上千种疗法进行管理，每种疗法都有其特定的条件。
计算方法对于管理这种复杂性至关重要。例如，在生产过程中选择最佳合作伙伴公司是通过像支持向量机这样的监督学习来完成的。
动态需求预测通常依赖于所谓的支持向量回归，而生产优化本身部署了神经网络。
结论
现代科技今天所能达到的成就非常令人着迷。它结合数据科学展现了最可观的价值。
就方法而言，我们看到监督学习方法——随机森林、朴素贝叶斯和支持向量机经常使用，强化学习、NLP 和深度学习占主导地位。
此外，需要处理高维数据和搜索的计算方法，如主成分分析和协方差模型。
在创新前沿工作需要特定主题的知识，如贝叶斯优化、卷积神经网络或暹罗网络。
这个领域最重要的入门障碍是特定主题的知识，从而理解(原始)数据。变得熟悉的最快途径是阅读科学出版物和每一个不为人知的表达，努力去查找。在那个领域工作时，你需要用专家的话说。
只有这样，你才能作为一名数据科学家发挥巨大的影响力。但这也是最有收获的方面。
生命科学和生物技术行业对我的工作影响最大。
你喜欢我的故事吗？在这里你可以找到更多。
数据科学的 8 个基本统计概念
入门
…用简单的英语解释
统计学是" 数学的一个分支，处理大量数字数据的收集、分析、解释和呈现 "。将编程和机器学习结合起来，你就能很好地描述数据科学的核心技能。
统计学几乎应用于数据科学的所有方面。它用于分析、转换和清理数据。评估和优化机器学习算法。它也用于展示见解和发现。
统计学的领域非常广泛，确定你到底需要学什么以及按照什么顺序学可能很困难。此外，学习这一主题的许多材料非常复杂，在某些情况下可能很难消化。特别是如果你没有高等数学学位，并且正在从软件工程等领域过渡到数据科学。
在下面的文章中，我将介绍学习数据科学时需要掌握的八个基本统计概念。这些不是特别高级的技术，但是它们是在学习更复杂的方法之前你需要知道的一些基本要求。
1.统计抽样
在统计学中，你可用于测试或实验的整套原始数据被称为总体。出于多种原因，您不一定能够衡量整个人口的模式和趋势。由于这个原因，统计学允许我们采取样本，对那组数据进行一些计算，并使用概率和一些假设，我们可以在一定程度上确定地了解整个人口的趋势或预测未来事件。
统计学允许我们采取一个样本或一部分人口，对那组数据进行一些计算，并使用概率和一些假设，我们可以在一定程度上确定地了解整个人口的趋势
比方说，我们想了解一种疾病(如乳腺癌)在整个英国人口中的患病率。出于实际原因，不可能对整个人口进行筛查。相反，我们可以采取随机抽样，并测量其中的流行程度。假设我们的样本足够随机，并能代表整个人口，我们就能得到一个患病率的衡量标准。
2.描述统计学
描述统计学，顾名思义，帮助我们描述数据。换句话说，它使我们能够理解潜在的特征。它不预测任何事情，不做任何假设，也不推断任何事情，它只是描述我们拥有的数据样本的样子。
描述性统计数据来源于计算，通常称为参数。其中包括以下内容:
- 均值— 中心值，俗称平均值。
- 中值 —如果我们将数据从低到高排序并将它精确地分成两半，中间值。
- 模式 -最常出现的值。
3.分布
描述性统计很有用，但它们通常会隐藏数据集的重要信息。例如，如果一个数据集包含几个比其他数据大得多的数字，那么平均值可能会有偏差，不会给我们一个真实的数据表示。
分布是一种图表，通常是直方图，显示每个值在数据集中出现的频率。这种类型的图表为我们提供了关于数据分布和偏斜度的信息。
分布通常会形成一个类似曲线的图形。这可能更偏向左边或右边。
“输血”数据集中的血容量分布。图片作者。
在某些情况下，曲线可能不平滑。
献血频率的分布。图片作者。
最重要的分布之一是正态分布，由于其形状通常被称为钟形曲线。它在形状上是对称的，大多数值聚集在中心峰值周围，而较远的值平均分布在曲线的每一侧。自然界中的许多变量会形成正态分布，如人的身高和智商得分。
正态分布。图片作者。
4.可能性
简单来说，概率就是事件发生的可能性。在统计学中，事件是实验的结果，可能是掷骰子或 AB 测试的结果。
一个单一事件的概率通过将事件数量除以所有可能结果的数量来计算。比如说，在骰子上掷出一个 6，有 6 种可能的结果。所以掷出 6 的几率是 1/6 = 0.167，有时这也用百分比表示，所以 16.7%。
事件可以是独立的或相关的。对于从属事件，前一个事件会影响后一个事件。假设我们有一袋 M 个& M，我们想确定随机挑选一个红色 M 个& M 的概率。如果每次我们从袋子中取出选中的 M 个& M，挑选红色的概率会由于先前事件的影响而改变。
独立事件不受先前事件的影响。对于 M&M 的袋子，如果每次我们选择一个，我们就把它放回袋子里。每次选择红色的概率保持不变。
一个事件是否独立是很重要的，因为我们计算多个事件发生概率的方式会因类型而异。
多个独立事件的概率通过简单地乘以每个事件的概率来计算。在掷骰子的例子中，假设我们想计算掷三次 6 的机会。这看起来像下面这样:
1/6 = 0.167 1/6 = 0.167 1/6 = 0.167
0.167 * 0.167 * 0.167 = 0.005
相关事件的计算是不同的，也称为条件概率。如果我们以 M & M 为例，假设我们有一个只有红色和黄色两种颜色的袋子，我们知道袋子里有 3 个红色和 2 个黄色，我们想计算连续挑选两个红色的概率。在第一次选择时，选择红色的概率是 3/5 = 0.6。在第二次选择时，我们已经移除了一个 M & M，它碰巧是红色的，所以我们的第二次概率计算是 2/4 = 0.5。因此，连续选中两个红色的概率是 0.6 * 0.5 = 0.3。
5.偏见
正如我们以前在统计学中讨论过的，我们经常使用数据样本对整个数据集进行估计。同样，对于预测建模，我们将使用一些训练数据，并尝试建立一个可以对新数据进行预测的模型。
偏差是统计或预测模型高估或低估一个参数的趋势。这通常是由于获取样本的方法或测量误差的方式造成的。在统计学中有几种常见的偏差。以下是对其中两种的简要描述。
- 选择偏差 —这发生在以非随机方式选择样本时。在数据科学中，一个例子可能是在测试运行时提前停止 AB 测试，或者从一个时间段选择数据来训练机器学习模型，这可能会掩盖季节性影响。
- 确认偏差 —当执行某些分析的人对数据有预先确定的假设时，就会出现这种情况。在这种情况下，可能会倾向于花更多的时间检查可能支持这一假设的变量。
6.差异
正如我们在本文前面所讨论的，样本数据的平均值就是中心值。方差衡量数据集中的每个值离平均值有多远。本质上，它是对数据集中数字分布的度量。
标准偏差是对具有正态分布的数据变化的常用度量。它是一种计算，给出一个值来表示这些值的分布范围。较低的标准偏差表明这些值倾向于非常接近平均值，而较高的标准偏差表明这些值更加分散。
如果数据不符合正态分布，则使用其他方差度量。通常使用四分位距。这种测量是通过首先按等级对值进行排序，然后将数据点分成四等份，称为四分位数得出的。根据中位数，每个四分位数描述 25%的数据点位于何处。四分位数范围的计算方法是减去两个中间四分之一的中位数，也称为 Q1 和第三季度。
箱线图提供了有用的四分位数范围的可视化。图片作者。
7.偏差/方差权衡
偏差和方差的概念对于机器学习非常重要。当我们建立机器学习模型时，我们使用称为训练数据集的数据样本。该模型学习该数据中的模式，并生成能够将正确的目标标签或值(y)映射到一组输入(X)的数学函数。
当生成该映射函数时，模型将使用一组假设来更好地逼近目标。例如，线性回归算法假定输入和目标之间存在线性(直线)关系。这些假设在模型中产生偏差。
作为计算，偏差是模型生成的平均预测值与真实值之间的差异。
如果我们使用不同的训练数据样本来训练一个模型，我们将得到返回的预测的变化。机器学习中的方差是衡量这种差异有多大的指标。
在机器学习中，偏差和方差构成了我们预测的总体预期误差。在一个理想的世界里，我们应该既有低偏差又有低方差。然而，在实践中，最小化偏差通常会导致方差增加，反之亦然。偏差/方差权衡描述了平衡这两个误差以最小化模型整体误差的过程。
8.相互关系
相关性是衡量两个变量之间关系的统计技术。相关性被假设为线性(在图形上显示时形成一条线)，并被表示为+1 和-1 之间的数字，这被称为相关系数。
相关系数+1 表示完全正相关(当一个变量的值增加时，第二个变量的值也增加)，系数 0 表示不相关，系数-1 表示完全负相关。
统计学是一个广泛而复杂的领域。本文旨在简要介绍数据科学中一些最常用的统计技术。通常，数据科学课程会假设学生事先了解这些基本概念，或者从过于复杂和难以理解的描述开始。在进入更高级的主题之前，我希望这篇文章将作为数据科学中使用的基本统计技术的复习。
感谢阅读！
我每月发一份简讯，如果你想加入请通过这个链接注册。期待成为您学习旅程的一部分！
创建专业数据科学笔记本的 8 条准则
创建笔记本时需要注意的一切
凯利·西克玛在 Unsplash 上的照片
笔记本电脑，如 Jupyter 或 RMarkdown，长期以来一直是数据科学家最常用的工具之一。
使用笔记本，您可以组织一个与数据相关的解决方案，并对您的工作有一个很好的格式描述。一个明显的优势是有可能使用 Markdown 直接记录项目的每个方面，以及每段代码。
然而，并不是每个人都以帮助他人正确再现结果的方式共享笔记本。我们都知道，再现性是任何数据科学研究的首要关注点。
下面，我将谈谈你必须考虑的 8 个要点，以确保你的笔记本易于遵循，并且在未来会受到任何读者和你自己的高度赞赏。
1.不要在每个单元格中执行太多操作
将代码单元和许多操作放在一起是一种不好的做法。这导致交互结果较少(只打印最后一行)，并且可能隐藏一些细节(用户可能需要更多时间来理解每个单元格在做什么)。
笔记本实际上有无限的电池。因此，不要在一个单元格中堆积大量代码，要确保自由地创建新的单元格来探索数据。
我不是说你应该有单行单元格。有意义的代码应该在同一个单元格中。在决定何时创建新的代码单元格时，请使用常识。
2.结构清晰，各部分组织有序
笔记本的结构比你想象的更重要。
有了清晰的笔记本结构，读者将能够:
- 容易理解整体想法；和
- 直接进入他们最感兴趣的项目部分。
所以，为了简单起见( KISS principle )，我们可以使用下面的结构:
1。简介
2。数据角力
3。探索性数据分析
4。造型(可选)
5。结论
这五个部分中的每一部分都有一些他们应该包含的要点，通常被组织成子部分。笔记本结构是一个至关重要的话题，但经常被低估。关于完整的讨论，请参见我的前同事 Ryan 的以下帖子:
3.注释你的情节的每个方面
绘图应该到处都有注释。目标是确保我们的情节具有充分的描述性。换句话说，它们应该是独立的，“易于解释”。
对于笔记本中提供的每个可视化内容，我们必须确保它们至少包含以下内容:
- x 轴和 y 轴上的标签，使用正确描述数据的文本，而不是使用变量名。
- 解释描述内容的标题。
- 如果必要的话，一个传说。
- 每个轴的单位，例如 y 轴标签上的“温度(摄氏度)”。
对于使用 python 注释绘图的好教程，我推荐 Matplotlib 教程。
4.滥用降价单元
为了真正利用笔记本，我们必须用降价单元来填补理解代码的所有空白。这个想法是解释每一个步骤、决定和结果。
虽然代码单元格中的注释有助于解释代码，但降价单元格应该有助于读者理解每一步的总体目标。
要创建 Markdown 单元格，只需按 ESC，然后按“m”，这将使一个代码单元格变成 Markdown。要了解更多关于这种简单得荒谬的语言，请看一下这个备忘单——这就是你使用 Markdown 所需要的全部。
5.确保“未来”单元格没有错误
有时在分析过程中，您向单元格添加代码并执行它们，然后，在这之后，您修改并运行它们之前的另一个单元格。这显然会造成一些不一致。
例如，使用在当前单元格下面的单元格中定义的变量将会产生错误。参见下面这个简单的例子，我们在第三个单元格上创建了一个数据帧df_cell_3，但是自顶向下运行代码，我们试图在第二个单元格被创建之前访问它:
“未来单元格”的错误示例。图片由作者提供。
因此，每次完成项目的某个部分后，重新启动笔记本并按顺序(从上到下)运行所有单元格来检查错误。在前进之前按顺序执行代码单元将确保一切都设置好，并且在创建之前不会使用“未来”变量/函数。
如果您总是重新启动笔记本以按顺序运行单元格，单元格左侧括号之间的数字将总是按升序排列。将这些数字按顺序排列进一步向每个人表明结果是有效的并且组织良好。
6.功能是你的朋友
不幸的是，在笔记本中使用重复代码仍然是一种普遍的做法。我的意思是，在单元格之间简单地复制和粘贴代码太容易了，对吗？
但是我们不应该使用样板代码，假装代码重复不是问题，而是应该尽可能地创建函数。
通过定义函数，我们可以重用代码并在需要时调整参数。这给了我们模块化代码的第一稿，可以用于生产中的实际应用程序。
此外，在使用函数时，记得包括文档字符串，这是一个通用的约定，为代码提供了所有的可维护性、清晰性和一致性。它增强了代码的可重用性和未来维护的可能性。点击链接了解更多关于文档字符串的信息。
7.仔细检查包裹并尽早列出它们
一个笔记本通常是经过多次迭代，尝试不同的包和功能后构建的。在分析的中间，你经常会添加一个包并使用它。当这种情况发生时，我们经常在笔记本中间的一个代码单元中有一个import命令。
所以关于导入代码，一个好的实践是识别所有使用的包，并在笔记本开始的代码单元中列出它们。这样，当打开笔记本电脑时，每个包装的使用情况立即显而易见。
更重要的是，这也有助于将代码转移到生产级脚本，因为包含笔记本所需包的需求文件将更容易识别。
8.一个焦点
在单个笔记本中编写代码来解决许多问题是很诱人的。然而，这样做可能会让未来的读者感到困惑，他可能就是未来的你自己。所以每个笔记本只定义一个目标。你会清楚地知道要期待什么，你的工作会更有条理。
当然，一次专注一件事会增加你拥有的笔记本数量。但是多两个或者更多笔记本都不是问题。创建多个笔记本总比过载一个笔记本好。
(奖金)导出您的笔记本
如果你想分享你的.ipynb文件，记得也把它导出到一个.html文件，这样其他人更容易查看内容。
要创建一个 HTML 文件，您可以在您的笔记本中添加一个代码单元，并为标题为My_Notebook.ipynb的笔记本添加以下代码:
将笔记本导出到 HTML 的代码。
感谢阅读。如果你有更多创建专业笔记本的最佳实践，请在下面的评论中告诉我。
如果你喜欢阅读这样的故事，并想支持我成为一名作家，可以考虑注册成为一名媒体会员。每月 5 美元，你可以无限制地阅读媒体上的故事。如果你用我的链接注册，我会赚一小笔佣金。
生产中威胁机器学习系统的 8 种危险
MLOps
维护 ML 系统时需要注意什么
《机器学习系统中隐藏的技术债务》中描述的一些问题，图片由作者提供。
开发和部署机器学习模型并不容易，更不容易将它们与周围的数据管道集成起来，以构建大规模的 ML 系统。然而，最困难的部分在后面，当整个系统已经被测试、部署、启动并运行时。因为部署绝不是旅程的终点。恰恰相反，这时一个新的挑战开始了:维护。
机器学习系统的维护成本在某些情况下可能会变得过高，我指的是工程师用来保持系统活跃和不受威胁的时间。在一篇谷歌论文“机器学习系统中隐藏的技术债务”中，作者指出了为什么会出现这种情况的多种原因，并提出了如何缓解一些问题的建议。让我们仔细看看其中的几个。
1.纠缠
纠缠是指机器学习系统的所有组件都是相互依赖的。与传统的软件开发不同，在传统的软件开发中，人们可以轻松地更新一段模块化代码，而无需破坏整个程序，在机器学习中，这是 CACE:改变任何东西都会改变一切。
机器学习系统的所有组件都是相互依赖的。改变任何事都会改变一切。
如果您为 ML 算法添加一个要学习的新特性，重新调整它的超参数，或者甚至改变数据归一化的方式，您就有可能完全改变系统的行为。明显？也许吧，但还是有一些问题。
假设您在数据预处理管道中发现了一个 bug。客观上明显错误的事情:例如，由于代码中的错误，两个不同类别的分类变量被视为一个。你应该修理它吗？如果你做了会怎么样？模型会突然收到这个在训练中从未见过的新特征值。这被称为数据漂移 。漂移可能会自然出现，通常是一个问题，但这是我们自己和我们的数据处理“修复”引入的。对模型的性能有什么影响？欢迎来到 CACE 世界:没人知道。它可能上升，或下降，或保持不变。
为了对抗纠缠，需要对模型行为中的任何意外变化保持警惕。这意味着广泛的监控和警报，尤其是当涉及到模型输入和输出的统计属性时。请随意阅读关于如何检测和应对漂移的更详细文章:
2.校正级联
另一个危险在于修正级联。在这种情况下，为了解决一个新问题，一个人根据另一个解决相关或类似问题的现有模型的输出来训练一个模型。通过这种方式，新模型学习了一种应用于旧模型输出之上的校正。我举个例子说明一下。
我曾经做过预测一些餐馆每天订单数量的问题。一旦部署了该模型，客户要求再部署一个模型，以预测外卖/送货订单的数量。交货订单是总订单的一部分，两者通常高度相关。由于现有的总订单模型运行得非常好，人们可能会认为预测送货订单的最佳或最简单的方法是建立一个简单的模型，比如说，具有两个功能:总订单预测和恶劣天气指示器(当天气寒冷或下雨时，人们倾向于在家订购食品而不是外出)。容易吗？当然可以。会准确吗？很可能是这样。我们应该这样做吗？见鬼不要。
在这个例子中，只应用了一个修正，但是假设客户要求 next 预测价值大于$15 的交货订单的数量。人们很容易接受交货订单预测，并在此基础上学习一个模型。通过这种方式，小的修正将迅速级联。为什么这么危险？
在现有模型的基础上构建新模型可能会导致改进死锁。
校正级联使得分析组成级联的特定模型的改进变得非常困难。在最坏的情况下，这会导致改进死锁，因为级联中任何部分的修复或改进都会导致系统级的更改。
除了层叠，更好的解决方案是增强现有模型来学习新任务。例如，我们可能会向预测订单总数的神经网络添加第二个输出，以预测交货订单的比例。这样，两个问题都可以在一个模型中得到很好的处理。如果这种扩充不可行，应该考虑为新问题从头开始建立一个新模型。这看起来像是额外的工作，但与维护模型级联的成本相比，这可能算不了什么。
3.未申报的消费者
通常的做法是将机器学习堆栈拆分成独立运行的子系统，如 cronjobs 或微服务。
想象一下，新数据以碎片文件的形式定期到达您的 S3 存储器。您可能希望设置一个 cronjob，它获取自上次运行以来出现的所有新文件，清理它们并将输出插入到数据库中。接下来，您将拥有一个数据预处理例程，它将从数据库中读取并执行缺失数据插补，特征工程等，并将预处理后的数据转储回 S3。接下来，你将需要一个模型训练器，它读取预处理后的数据，训练一个机器学习模型，并将其保存在某个地方。最后一步将是一个微服务，它带有一个服务于模型预测的 API。
所有这些都是一个单一的系统，被分离成独立的部分，但服务于一个单一的目的:提供一个机器学习模型。这种结构是一种很好的做法，但也带来了一个危险:它会产生一些中间输出(数据库中的数据、S3 上的预处理数据、保存在 S3 上的训练模型)，这些输出可能对其他任务有用。从事其他项目的团队可能想要使用其中的一些中间产出，但经常无法正确地宣布，这使得他们成为未宣布的(或沉默的 ) 消费者。
未声明的消费者在看似不相关的系统之间创建了隐藏的依赖关系。
这是一个严重的风险，因为它在系统之间建立了依赖关系，而这些依赖关系可以被合理地认为是完全不相关的。因此，改善一个系统可能会破坏另一个系统。为了防范未申报的消费者，最好有严格的访问限制。然后，即使一些系统从另一个不应该使用的系统中使用，这至少会以访问列表的形式记录下来。
4.不稳定的数据依赖关系
如前所述，机器学习模型通常依赖于其他系统的输出，如数据处理例程或其他预测模型。即使在我们通过实施访问限制解决了未申报消费者的问题之后，还有一个威胁即将出现:特定子系统的不稳定性。
数据收集设备有时会发生故障，数据提供商可能会遭遇技术问题，预测模型容易受到数据和概念漂移的影响，您自己的代码可能会隐藏在最意想不到的时刻突然出现的错误。这种事情确实会发生。因此，您的数据处理例程可能会突然接收垃圾作为输入。你能猜到输出会是什么吗？
对所有子系统的输出进行版本控制可以保护你不被不稳定的依赖所浪费。
为了减轻不稳定数据依赖的问题，对每个子系统的输出进行版本化是一个很好的实践。这可以简单到用当前时间戳标记每个数据预处理器的输出。然后，您可以冻结下游机器学习模型，以使用某一天的输入数据，并且只有在您检查了最近的数据没有问题后，才更新它。
5.未充分利用的数据相关性
在传统的软件工程中，未充分利用的依赖项是代码中导入的包，但实际上并不真正需要。随着机器学习的参与，问题的一个新的方面出现了:未充分利用的数据依赖性，即系统使用的数据，但没有提供多少建模好处。拥有太多这种未充分利用的依赖关系会使系统暴露于已经讨论过的不稳定性问题，即使它们可以被移除而不会造成太大的损害。
机器学习系统中未充分利用的数据有四个主要来源:
- 遗留特性在模型开发的早期阶段是有用的，但是后来变得多余，并且没有被监督删除。
- 捆绑特征，即以某种方式相关的特征，其对模型性能的影响是针对整个捆绑进行评估的。有些可能真的不需要。
- features，这是为模型提供很少增益的特征。删除它们可能不会对模型造成太大的损害，并且可能是比保留和维护它们更好的决定。
- 以非常相似的模式变化的相关特征可以被认为几乎是重复的。如果基于领域知识可以确定哪一个对目标有因果影响，那么应该只保留这一个。
只保留模型中有助于其良好性能的那些特征。放下剩下的。
一个好的做法是定期对数据进行逐个功能的检查，以识别并删除冗余的数据。为了使这种选择更加以数据为导向，可以考虑以不考虑要素的方式评估模型的度量。如果删除一个特性不会降低指标，那么就把它从代码库中完全删除。
6.反馈回路
机器学习模型通常被设计成以某种方式影响现实世界。比方说，您可能希望有一个模型来预测某些网站内容的点击率，以便选择最大化点击次数的内容，从而增加收入。当模型通过影响世界来影响自身，从而产生一个反馈回路时，问题就出现了。
假设上述模型部署在网站上。这意味着用户点击的新数据不仅反映了他们对内容的喜欢程度，还反映了该内容被模型推荐的力度。这样，当您想要改进、更新或重新训练模型时，您可以使用的训练数据将是模型本身的间接结果。这可能会阻止模型了解用户真正喜欢什么。
始终确保您的训练数据不受模型本身的影响。这种反馈循环阻止了模型学习真实世界。
补救措施是将数据的一部分隔离开来，使其不受模型的影响。在本例中，您可以留出一部分随机选择的用户，向他们显示不是由模型选择的内容，而是随机内容或基于简单业务规则选择的内容。
7.粘合代码
大多数机器学习系统严重依赖开源包，无论是用于训练模型的通用库，如 scikit-learn 或 TensorFlow，还是用于数据处理的特定领域包。这通常会产生大量的粘合代码，粘合代码是用来转换、重新表达、整形、压缩、传播、重新排列或以其他方式处理数据的支持代码，以便将数据输入和输出所有这些包。
这可能是昂贵的，因为系统被所使用的特定包的细节所冻结，并且尝试替代的、也许更好的解决方案变得非常昂贵。
用于外部包的公共 API 防止胶合代码，并使系统更加模块化。
缓解这个问题的一个方法是将外部包封装到公共 API 中，从而更容易替换系统的各个部分。
8.死实验代码路径
粘合代码模式的结果之一是，试验系统的最简单方法是在生产代码中以 if 语句的形式添加试验代码。这看起来很有吸引力，因为对于任何单个实验来说，都不需要调整剩余的代码。
然而，随着时间的推移，实验代码会越来越多，使得维护和正确测试整个系统变得更加困难，在最坏的情况下，实验代码可能会在生产中意外执行，这可能是灾难性的。
不要在生产代码中进行实验。建立一个独立的实验框架。
最好有一个单独的实验框架，用于试验想法和微调模型。如果这是不可能的，请确保定期检查并从产品代码中删除无用的实验代码路径。每个实验都应该以实施新的生产解决方案或者放弃它而告终。如果您使用的是版本控制系统，比如 git，那么您总是可以回到旧的实验代码。不需要将它保存在生产代码库中。
外卖食品
- 机器学习系统的所有组件都是相互依赖的。改变任何事都会改变一切。设置监控和警报，以便在早期检测模型行为中的任何意外变化。
- 模型级联，或者在现有模型的基础上构建新模型，可能会导致改进死锁。最好扩充现有的模型来学习新的任务，或者为每个任务建立一个单独的模型。
- 未声明的消费者在看似不相关的系统之间创建了隐藏的依赖关系。始终设置访问限制，以便了解哪些系统依赖于哪些输入。
- 始终对所有子系统的输出进行版本控制，以保护下游系统不会因为不稳定的依赖关系而消耗垃圾。
- 只保留模型中有助于其良好性能的那些特征。放下剩下的。
- 始终确保您的训练数据不受模型本身的影响。这种反馈循环阻止了模型学习真实世界。
- 用于外部包的公共 API 防止胶合代码，并使系统更加模块化。
- 不要在生产代码中进行实验。建立一个独立的实验框架。如果这是不可能的，请确保定期检查并从产品代码中删除无用的实验代码路径。
来源
斯卡利、D &霍尔特、加里&戈洛文、丹尼尔&达维多夫、尤金&菲利普斯、托德&埃布纳、迪特马尔&乔德里、维奈&杨、迈克尔&丹尼森、丹。(2015).机器学习系统中隐藏的技术债务。乳头。2494–2502.[ 链接
感谢阅读！
如果你喜欢这篇文章，为什么不在我的新文章上 订阅电子邮件更新 ？而通过 成为媒介会员 ，就可以支持我的写作，获得其他作者和我自己的所有故事的无限访问权。
需要咨询？你可以问我任何事情，也可以在这里 为我预约 1:1 。
你也可以试试我的其他文章。不能选择？从这些中选择一个:
</8-tips-for-object-oriented-programming-in-python-3e98b767ae79> [## Python 中面向对象编程的 8 个技巧
towardsdatascience.com](/8-tips-for-object-oriented-programming-in-python-3e98b767ae79)
增强现实的 8 种方式
构建模块/分解/解释
AR 要被广泛接受需要什么？
本文将研究“如何做？”这让有了“为什么？”列在我上一篇帖子里— 增强现实的 10 个为什么 。强烈建议用上一篇文章中的视觉场景来刷新你的记忆，以便更好地理解下面列出的概念。
免责声明:这是从我过去使用围绕扩展现实(XR) 的产品的经验中推断出来的解释:
- ARCore ， ARKit ， WebXR ， Vuforia
- Project Tango ， Kinect ， Vuzix ， LeapMotion now UltraLeap ， Tobii ， Vive ， Oculus ，英特尔实感技术，英特尔项目合金， Daqri ， Hololens 和
采用由外向内的方法，消费者对理想增强现实设备的明显要求将被广泛接受:
- 符合人体工程学的外形(重量轻，长期日常使用)
- 易于使用和开发
- 增强内容与真实环境无缝融合
为了到达这里，我们需要什么？
1.增强内容原地不动(本地 SLAM 和传感器)
随着我们真实视觉中最轻微的移动，一个增强的浮动面板应该保持固定，就像我们的沙发保持固定一样，当我们四处移动时，我们只能看到沙发的不同视角。
让我们做一个练习——先看你的左边，然后看你的右边，闭上你的眼睛。闭上眼睛，稍微移动一下，以确保远离最初的观察点。不要睁开眼睛，试着想象新地点的空间视角？最后打开&比较。够近吗？
我们的耳朵不断地评估我们的运动，即使你在一个新的空间闭上眼睛，你也能粗略地评估我们的运动。当我们的眼睛睁开时，我们的运动感觉更加准确。
IMU (陀螺仪、加速度计)代替耳朵，两个或两个以上超广角高刷新率摄像头代替我们的眼睛。一种基于轻量级传感器融合的 SLAM 算法结合了来自两种技术的输入，构成了我们大脑评估我们周围空间运动的能力。
来自 github 演示的 T265 实感 vSLAM 模块—图片由作者提供
我们不需要理解我们周围的整个空间(地图)——只需要承认我们的微小运动。我们走得越远，随着时间的推移，我们可能积累的错误就越多。在这里，我们的记忆开始发挥作用，这种能力将在下一节中讨论。
2.将内容与环境相关联(全球 SLAM)
我们还需要一个强大的计算昂贵的 slam 来映射我们当前所处的各个空间，以周期性地关联心理地图。
为了最大限度地减少我们轻量级可穿戴设备上的计算并延长电池寿命，我们可以通过与别处(远程)存储和处理的稀疏(非密集)地图进行交叉检查来纠正自己。就像购物中心里的地图，它就在购物中心里，我们不需要把它带回家。
ORBSLAM2 和 OpenVSLAM(EOL)演示——图片由作者提供
视觉传感器可以定期向外部设备发送数据，以了解我们的位置，并纠正我们对空间的局部理解。
想想轻量级本地 slam(可穿戴设备上)与全球 slam(如谷歌地图)在其他地方运行，而在我们所处的空间的前提下保持安全。为了解决隐私问题，全球地图由空间所有者维护，例如商场、商店、私人住宅或 AR 设备切换和连接的办公室，就像我们在星巴克接入 wifi 一样。
3.感知三维世界(深度感应)
我们自然地感觉到深度——某物有多远，某物有多大或多小。让我们做另一个练习。
闭上双眼，然后睁开一只眼睛，同时将拇指放在鼻子前面。观察大小、方向和一维拇指。然后睁开另一只眼睛，注意不同之处。你看到了什么？
通过结合你左右眼的视差，我们可以感知深度，从而看到三维世界。AR 设备也需要这种能力来估计物体的角度和遮挡——前面有什么，后面有什么，以及某物有多远；在我们的三维世界中进行直观的互动。想想粘在墙上或放在厨房台面上的浮动面板。
使用来自 StereoLabs 的 ZED 演示进行空间制图
对我们周围的环境进行 3D 重建的想法计算量很大，可以卸载到其他地方。AR 设备仍然可以显示增强的内容，这损害了没有这种功能的可信度，使其介于必须拥有和最好拥有之间。
4.与扩充内容交互(输入跟踪)
虽然技术本身没有限制，从视线跟踪、设备上的触摸板、基于语音的输入到输入控制器，但我们有权使用我们大多数人幸运地配备的东西——两只手！
为了无缝地跟踪我们灵活的伸出的手，我们可以利用现有的用于 SLAM 的宽视野摄像机。我们可以将实时使用的计算简化为:
- 基于深度的遮挡贴图(用于渲染和物理碰撞),无需完全跟踪手部骨骼关节(20)。
- 跟踪接触点的 5 个图形提示并检测多帧手势
来自代码为的纸张的 HandNet
5.开发和渲染引擎(Unity 和 Unreal)
两个领先的移动开发平台是 Android (Java，Kotlin: SDK & C/C++: NDK)和 iOS (Objective-C & Swift)。AR 是一种视觉媒体，其中应用程序逻辑与三维渲染组件结合在一起，这是游戏引擎提供编写逻辑的功能，并将物理和照明考虑在内。它们还为图形处理单元(GPU)和 CPU (Linux、macOS、Windows)上的操作系统调用提供了隐藏底层低级图形细节的抽象( OpenGL 、 DirectX 、 Vulkan )。开发人员可以消除渲染计算机生成的图像所需的顶点、三角形和模拟光、暗、透明度和颜色的迷你程序(着色器)的本质细节，并专注于纯粹的应用体验。
Unity 和 UE4 游戏引擎演示——作者图片
可穿戴 AR 设备上的计算越多，就会越重，越耗电，越发热。利用 wifi6 和 5G 的强大连接，随时随地卸载计算的优势，我们可以将 AR 设备简化为一个发送传感信息以在其他地方处理的编码器，一个解码返回到显示器的内容的解码器。
想象一下，开发人员可以自由地在任何现有的 AppStore 中部署 AR 应用程序，这些应用程序可以在任何有能力的设备上运行，但结果会以无线方式显示在 AR 设备上。
6.非应用程序逻辑组件即远程服务(微服务)
在上一节中，我们主要讨论了前端(例如浏览器的网页)，那么后端(例如存储、算法)呢？随着在 Kubernetes 等编排系统中运行或在远程系统上的 docker 中简单运行的容器化微服务的流行，生态系统仍然可以在 SLAM、AI 和其他计算机视觉算法上进行创新，作为一种微服务，只向渲染引擎提交所需的结果，以实现注重用户体验的应用程序逻辑。
软件和硬件组件—按作者分类的图片
假设场景:想象一下，如果所有的行业参与者都可以自由地创新和发展他们已经擅长构建的组件，AR 创新的步伐会有多快？显示器、CPU、GPU、操作系统、VPU、无线等都可以利用其现有的生态系统和市场来提供常见的增强现实消费产品。
7.增强显示技术
这是 AR 最难的部分——成本、功耗、显示分辨率、亮度、视野！要解释波导的现状(全息、衍射、偏振和反射)，还需要一篇很长的文章。这里有一篇由 Kore 撰写的关于这一主题的有据可查的媒体文章:
注意:在这个领域有更多的创新
例如 Ostendo 、 nreal 、 nueyes
8.借助第三方技术增强 AR
理想的 AR 体验的很大一部分可以通过与其他不能在设备本身上运行的技术合作来实现。
- AI: 从可以实时生成动态图像(可视化我们的想象力、deepfakes 和虚拟化身代理)的 GANs，到可以学习我们的动作以适应、推荐和优化我们日常任务的增强内容的网络。
- 物联网:智能空间的传感器不断生成可以在其他地方进行分析的数据，情境化的信息可以在我们的视野中得到增强，以更快地做出决策(预测性维护、交通信号灯、自主引导车辆和机械臂)
- 云游戏:这可以扩展到直接在 AR 设备上消费 OTA 流媒体内容。
结论
你可能会注意到上述方法中的一种模式，其中 5G ( URLLC ，企业空间中的私有 5G)，wifi6(小型个人空间中的多用户)，IoT(智能城市/工厂/工作场所/家庭)，分布式计算(从边缘到云的远程处理)，作为可扩展微服务交付的算法能力，应用体验的渲染引擎(Unity & Unreal)都协同工作，以提供理想的 AR 体验。这项技术已经在回答“增强现实被广泛接受需要什么？”但是这只是“我们如何实现目标”的众多观点之一
给你留下我(2020 年)DIY 的早期原型树莓 Pi 4 +轻量级 T265 SLAM+ Pepper 的幽灵效果用于 AR 显示+Wifi+power bank+win 10 Unity 上的远程处理+ WSL docker 微服务希望解锁我上一篇帖子中总结的可能性
增强现实的 10 个为什么 。
DIY 早期原型(个人项目)——作者图片
Python 熊猫处理缺失值的 8 种方法
#7:使用前一个或下一个值
除非另有说明，所有图片均由作者创作。
缺失值可能是数据科学中最不想要的值。我们绝对不想要它们。但是，他们总是在身边。
因为忽略丢失的值是不合理的，所以我们需要找到有效和正确处理它们的方法。
Pandas 是最好的数据分析和操作库之一，在处理缺失值方面非常灵活。
在这篇文章中，我们将介绍 8 种不同的方法来消除丢失的值，而不会引起很多麻烦。哪种方法最适合特定情况取决于数据和任务。
让我们首先创建一个样本数据框，并向其中添加一些缺失值。
(图片由作者提供)
df 的前 5 行(图片由作者提供)
我们有一个 10 行 6 列的数据框。
下一步是添加缺失的值。我们将使用 loc 方法来选择行和列的组合，并使它们等于“np.nan ”,这是标准的缺失值表示之一。
(图片由作者提供)
以下是数据框现在的样子:
df(作者图片)
item 和 measure 1 列具有整数值，但由于缺少值，它们已被向上转换为 float。
在 Pandas 1.0 中，引入了整数类型缺失值表示(
(图片由作者提供)
df(作者图片)
我们现在能够保留整数列，尽管有丢失的值。
我们的数据框缺少一些值。是时候看看处理它们的不同方法了。
1.删除缺少值的行或列
一种选择是删除包含缺失值的行或列。
(图片由作者提供)
(图片由作者提供)
使用默认参数值，dropna 函数将删除包含任何缺失值的行。
数据框中只有一行没有任何缺失值。
我们还可以通过使用 axis 参数来选择删除至少有一个缺失值的列。
(图片由作者提供)
(图片由作者提供)
只有日期列没有任何缺失值。
1.删除只有缺失值的行或列
另一种情况是一列或一行充满了缺失值。这样的列或行是无用的，所以我们可以删除它们。
dropna 函数也可以用于此目的。我们只需要改变 how 参数的值。
(图片由作者提供)
(图片由作者提供)
由于数据框中没有充满缺失值的行，因此没有删除任何行。
1.根据阈值删除行或列
基于“任何”或“全部”的删除并不总是最佳选择。我们有时需要删除“大量”或“一些”缺少值的行或列。
我们不能将这样的表达式赋给 how 参数，但是 Pandas 给了我们一个更精确的方法，即 thresh 参数。
例如，“thresh=4”意味着将保留至少有 4 个非缺失值的行。其他的会被放弃。
我们的数据框有 6 列，因此缺少 3 个或更多值的行将被删除。
(图片由作者提供)
(图片由作者提供)
只有第三行缺少 2 个以上的值，所以它是唯一被删除的行。
4.基于列的特定子集删除
在删除列时，我们可以只考虑一些列。
dropna 函数的 subset 参数用于此任务。例如，我们可以删除 measure 1 或 measure 2 列中缺少值的行，如下所示:
(图片由作者提供)
(图片由作者提供)
到目前为止，我们已经看到了基于缺失值删除行或列的不同方法。
放弃不是唯一的选择。在某些情况下，我们可能会选择填充缺失的值，而不是删除它们。
事实上，填充可能是一个更好的选择，因为数据意味着价值。当然，如何填充缺失的值取决于数据的结构和任务。
fillna 函数用于填充缺失的值。
5.用常数值填充
我们可以选择一个常数值作为缺失值的替换。
如果我们只给 fillna 函数一个常量值，它会用该值替换数据框中所有缺失的值。
更合理的方法是为不同的列确定单独的常数值。我们可以将它们写在字典中，并将其传递给 values 参数。
(图片由作者提供)
(图片由作者提供)
“项目”列中缺少的值将替换为 1014，“度量 1”列中缺少的值将替换为 0。
6.用聚合值填充
另一种选择是使用聚合值，如平均值、中值或众数。
以下代码行将 measure 2 列中缺少的值替换为该列的平均值。
(图片由作者提供)
7.替换为上一个或下一个值
可以用一列中的上一个或下一个值替换该列中缺少的值。
在处理时序数据时，这种方法可能会派上用场。假设您有一个包含每日温度测量值的数据框，但缺少一天的温度。最佳解决方案是使用第二天或前一天的温度。
fillna 函数的方法参数用于执行此任务。
(图片由作者提供)
(图片由作者提供)
“bfill”向后填充丢失的值，以便用下一个值替换它们。
看看最后一栏。缺失的值将被替换到第一行。这可能不适合某些情况。
幸运的是，我们可以限制用这种方法替换的缺失值的数量。如果我们将 limit 参数设置为 1，那么丢失的值只能用它的下一个值替换。后面的第二个或第三个值将不用于替换。
(图片由作者提供)
(图片由作者提供)
8.使用另一个数据框填充
我们还可以将另一个数据帧传递给 fillna 函数。新数据框中的值将用于替换当前数据框中缺失的值。
将根据行索引和列名选择这些值。例如，如果项目列的第二行中缺少值，将使用新数据框中相同位置的值。
df2(图片由作者提供)
df(作者图片)
上面是两个列相同的数据框。第一个(df2)没有任何缺失值。
我们可以如下使用 fillna 函数:
(图片由作者提供)
(图片由作者提供)
关于列名和行索引，df 中的值被替换为 df2 中的值。
缺失的价值观会一直存在于我们的生活中。没有处理它们的最佳方法，但是我们可以通过应用准确和合理的方法来降低它们的影响。
我们已经介绍了处理缺失值的 8 种不同方法。使用哪一个取决于数据和任务。
如果你还不是中级会员并计划成为其中一员，我恳请你使用以下链接。我将收取你的一部分会员费，不增加你的额外费用。
https://sonery.medium.com/membership
感谢您的阅读。如果您有任何反馈，请告诉我。
衡量分类性能的 8 项指标
入门
…用简单的英语解释
分类是一种有监督的机器学习问题，其目标是针对一个或多个观察值预测它们所属的类别或类。
任何机器学习工作流的一个重要元素是评估模型的性能。在这个过程中，我们使用训练好的模型对以前看不见的标记数据进行预测。在分类的情况下，我们然后评估这些预测中有多少是正确的。
在现实世界的分类问题中，一个模型通常不可能 100%正确。因此，在评估一个模型时，不仅要知道这个模型有多错，还要知道这个模型错在哪里。
“所有的模型都是错误的，但有些是有用的”，乔治·博克斯
例如，如果我们试图预测一个肿瘤是良性的还是癌性的，我们可能会更乐意放弃在少数情况下错误预测肿瘤是癌性的模型。而不是错过癌症诊断的严重后果。
另一方面，如果我们是决定哪些交易是欺诈性交易的零售商，我们可能会更乐意错过少量的欺诈性交易。而不是冒着失去好顾客的风险。
在这两种情况下，我们会优化模型以更好地实现某些结果，因此我们可能会使用不同的指标来选择最终要使用的模型。作为这些权衡的结果，在选择分类器时，您应该使用多种指标来优化特定用例的模型。
在下一篇文章中，我将简单描述八种不同的性能指标和技术，您可以用它们来评估一个分类器。
1.准确(性)
一个模型的总体精度就是正确预测的数量除以预测的总数。精确度分数将给出 0 到 1 之间的值，值 1 将指示完美的模型。
准确性。作者图片
该指标很少单独使用，因为在不平衡的数据中，一个类比另一个类大得多，准确性可能会产生很大的误导。
如果我们回到癌症的例子。想象一下，我们有一个数据集，其中只有 1%的样本是癌症。简单地预测所有结果为良性的分类器将达到 99%的准确率。然而，这种模型实际上是无用和危险的，因为它永远不会检测到癌变的观察结果。
2.混淆矩阵
一个混淆矩阵是一个非常有用的工具，可以用来观察模型在哪些方面是错的(或对的！).它是一个矩阵，比较每个类别中正确的和不正确的预测数。
在混淆矩阵中，有 4 个数字需要注意。
真阳性:模型正确预测为阳性的阳性观察值的数量。
假阳性:模型错误预测为阳性的阴性观察值的数量。
真阴性:模型正确预测为阴性的阴性观察值的数量。
假阴性:模型错误预测为阴性的阳性观察值的数量。
下图显示了分类器的混淆矩阵。利用这一点我们可以理解以下内容:
- 该模型正确预测了 3，383 个阴性样本，但错误预测了 46 个阳性样本。
- 该模型正确预测了 962 个阳性观察值，但错误预测了 89 个阴性观察值。
- 我们可以从这个混淆矩阵中看到，数据样本是不平衡的，负类具有更高的观察量。
混淆矩阵示例(使用 Pycaret 绘制)。作者图片
3.AUC/ROC
诸如逻辑回归之类的分类器将返回属于特定类的观察值的概率作为预测输出。为了使模型有用，这通常被转换成二进制值，例如，样本要么属于该类，要么不属于该类。为此，使用分类阈值，例如，我们可以说，如果概率高于 0.5，则样本属于类别 1。
ROC (接收器工作特性)曲线是模型在所有分类阈值下的性能图(真阳性率和假阳性率的图)。 AUC 是对曲线下整个二维面积的测量，因此是对模型在所有可能的分类阈值下的性能的测量。
ROC 曲线描绘了模型的准确性，因此最适合在数据不不平衡的情况下诊断模型的性能。
ROC 曲线示例(使用 Pycaret 绘制)。作者图片
4.精确
Precision 衡量模型正确识别正类的能力。换句话说，在所有对积极类的预测中，有多少是正确的？单独使用这个指标来优化一个模型，我们将使假阳性最小化。这对于我们的欺诈检测示例来说可能是可取的，但对于诊断癌症来说用处不大，因为我们对遗漏的阳性观察结果了解甚少。
精准。作者图片
5.回忆
回忆一下告诉我们该模型在正确预测数据集中所有积极观察方面有多好。然而，它不包括关于假阳性的信息，所以在癌症的例子中会更有用。
通常，精确度和召回率是通过构建精确度-召回率曲线来一起观察的。这有助于可视化不同阈值下两个指标之间的权衡。
6.F1 分数
F1 分数是精确度和召回率的调和平均值。F1 分数将给出一个介于 0 和 1 之间的数字。如果 F1 分数是 1.0，这表示完美的精确度和召回率。如果 F1 分数为 0，这意味着精确度或召回率为 0。
F1 分数。作者图片
7.卡帕
kappa 统计将观察到的精度与预期精度或随机期望的精度进行比较。纯粹准确性的一个缺陷是，如果一个类是不平衡的，那么随机进行预测可能会得到很高的准确性分数。Kappa 通过将模型精度与基于每个类中实例数量的预期精度进行比较来说明这一点。
本质上，它告诉我们，与根据每一类的频率对观察值进行随机分类的模型相比，该模型的表现如何。
卡帕统计。作者图片
Kappa 返回值等于或小于 1，负值是可能的。这种统计的一个缺点是没有一个公认的标准来解释它的值。尽管 Landis 和 Koch 在 1977 年给出了度量的一般解释。
卡帕解释(兰迪斯和科赫 19771)。作者图片
8.玛丽勒本板球俱乐部
MCC(Matthews Correlation Coefficient)通常被认为是分类模型的最佳性能度量之一。这主要是因为，与前面提到的任何指标不同，它考虑了所有可能的预测结果。如果在等级中有不平衡，这将因此被考虑。
MCC 本质上是观测分类和预测分类之间的相关系数。与任何相关系数一样，其值将介于-1.0 和+1.0 之间。值+1 表示完美的模型。
马修斯相关系数。作者图片
在本文中，我们简单解释了八个度量分类模型性能的标准。在实践中，很少会单独使用这些指标。更常见的情况是，数据科学家会评估这些分数，并在优化模型时权衡它们所揭示的权衡。
评估分类器的性能通常并不简单，并且高度依赖于用例以及可用的数据集。理解在特定方向上出错的风险尤为重要，这样你才能产生一个真正有用的模型。
感谢阅读！
数据科学家必备的 8 个 Git 命令
这就是你对项目的贡献
经过长时间的努力工作和奉献，您获得了作为数据科学家的第一份工作。适应和熟悉环境的时期结束了。你现在被期望从事现实生活中的项目。
分配给你的任务是编写一个执行项目中特定任务的函数。您的函数将是当前正在运行的现有项目的一部分。
你不能只在你当地的工作环境中编写函数，然后用电子邮件分享。应该在项目中实施。您需要将您的函数“合并”到当前的代码库中。
在大多数情况下，你不会是唯一一个对项目有贡献的人。考虑每个贡献者负责编写项目的一小部分。如果没有一个合适而有效的系统，将各部分组合起来将是一项繁重而乏味的任务。随着项目变得越来越大，不可能维持组合这些小部分的过程。
幸运的是，我们有 Git，它提供了一个高度实用的无缝操作来跟踪项目中的所有变更。
Git 是一个版本控制系统。它维护对代码所做的所有更改的历史记录。这些变化存储在一个特殊的数据库中，称为“存储库”，也称为“回购”。
在本文中，我们将介绍 8 个基本的 git 命令。
1.git 克隆
Git clone 在您的本地工作环境中创建项目的副本。你只需要提供一个项目的路径。这个路径可以从 GitLab 和 GitHub 等托管服务上的项目 main 中复制。
#clone with HTTPSgit clone [https://gitlab.com/*](https://gitlab.com/invent-analytics/koctas-pricing-app.git)******#clone with SSHgit clone [git@gitlab.com](mailto:git@gitlab.com):*******
2.git 分支
一旦您在本地克隆了项目，您在本地就只有主分支了。您应该在一个新的分支上进行所有的更改，这个分支可以使用 git branch 命令创建。
git branch mybranch
在您进行任何更改之前，您的分支是主分支的副本。
3.git 开关
创建一个新的分支并不意味着你正在处理这个新的分支。你需要切换到那个分支。
git switch mybranch
你现在在“我的分支”上，你可以开始改变了。
4.git 状态
它提供了当前状态的简要概述。你会看到你在哪个分支上工作。它还显示了您是否进行了任何更改或提交了任何内容。
git status
On branch mybranch
nothing to commit, working tree clean
5.git 添加
当您在代码中进行更改时，您所处理的分支将与主分支不同。除非您采取一系列操作，否则这些更改在主分支中是不可见的。
第一个动作是 git add 命令。该命令将更改添加到所谓的临时区域。
git add <filename>
基本 git 工作流程(图片由作者提供)
6.git 提交
将更新的文件或脚本添加到临时区域是不够的。您还需要使用 git commit 命令“提交”这些更改。
git commit 命令的重要部分是消息部分。它简要说明了更改的内容或更改的目的。
编写提交消息没有一套严格的规则。信息不应该太长，但应该清楚地解释变化是什么。随着使用 git 的经验增加，我想你会习惯的。
git commit -m "Your message"
7.git 推送
add 和 commit 方法在本地 git 存储库中进行更改。为了在远程分支(即主分支)中存储这些更改，您首先需要推送您的代码。
值得一提的是，像 PyCharm 这样的一些 ide 允许从用户界面提交和推送。但是，您仍然需要知道每个命令的作用。
推送你的分支后，你会在终端看到一个链接，会带你去托管服务网站(如 GitHub，GitLab)。该链接将打开一个页面，您可以在其中创建合并请求。
合并请求是要求项目的维护者将您的代码“合并”到主分支。维护者会首先检查你的代码。如果更改没问题，您的代码将被合并。
维护者也可能中止您的分支并恢复主分支。
8.git 拉
使用版本控制系统来维护有许多参与者的项目的目的。因此，当您在本地分支中处理任务时，远程分支中可能会有一些变化。
git pull 命令用于更新您的本地分支。您应该使用 git pull 命令用远程分支中的最新文件更新本地工作目录。
结论
Git 是数据科学家的必备技能。为了有一个协作和多产的工作环境，用版本控制系统维护项目是绝对必要的。
我们已经介绍了 8 个基本的 git 命令。您需要学习更多的 git 命令。本文中的这些将是一个良好的开端。
感谢您的阅读。如果您有任何反馈，请告诉我。
Python 中 8 个必须知道的文件系统操作
Python 在任务自动化应用中的本质
近年来，Python 被更多的非程序员所了解。这不仅是因为它在机器学习领域很受欢迎，还因为它可以用来自动化许多重复的工作，如批量编辑具有特定模式的文件。
当自动化任务与文件相关时，掌握 Python 中的文件系统接口非常重要。在本文中，我将介绍 Python 中最重要和最基本的 8 种文件系统操作。希望可以指导一些学习者有一个比较轻松的开始。
所有的源代码都可以在已经公开的 Google Colab 笔记本上找到。请找到上一节的链接，自己试试吧！
1.显示当前目录
我想开始的第一个操作是显示当前的工作目录(CWD)。这一点很重要，因为我们可能在大多数时候都想使用相对路径。因此，有时知道我们此刻在哪里是很重要的。
推荐使用相对路径的原因之一是它不会对应用程序造成限制。不管是谁复制了你的应用程序，它也应该在他们的计算机上运行。
好的。为了显示当前的工作目录，我们需要使用 OS 库。这个库是 Python 内置的，大部分文件操作函数都可以在这里找到。
import osos.getcwd()
它很容易记住，所以我建议记住它，以节省我们每次搜索的时间。
请注意，我用的是谷歌 Colab。所以，路径/content实际上是一个绝对路径。
2.检查目录或文件是否存在
在引入任何用于创建的函数之前，我们需要知道在创建之前检查某个东西是否已经存在是一种好的方式。这不仅是因为可能会有错误，也是为了避免不小心覆盖了某些内容。
函数os.path.exists()接受一个字符串类型的参数，它可以是目录名或文件名。
就我而言，我使用的是 Google Colab，每次配置新笔记本时，都会自动创建一个名为“sample_data”的文件夹。如果我想检查是否有这样的目录，下面的代码就可以了。
os.path.exists('sample_data')
如果我们想检查一个文件的存在，它也支持如下的文件名。
os.path.exists('sample_data/README.md')
当然，如果我们检查不存在的东西，它将返回 false。
3.连接路径组件
在前一个例子中，我故意展示了一种糟糕的编码风格。也就是在字符串'sample_data/README.md'中，我明确使用了正斜杠作为路径成分分隔符。
这个可以，但是不推荐。如果您希望您的 Python 应用程序能够跨平台运行，这样做是不安全的。例如，一些旧版本的 Windows 操作系统可能只识别反斜杠\作为分隔符。
别担心，Python 可以通过使用函数os.path.join()很好地处理这个问题。假设我们想使用 join 函数重写前面示例中的函数，应该如下所示。
os.path.exists(os.path.join('sample_data', 'README.md'))
4.创建目录
现在，让我们在工作目录中创建一个名为test_dir的目录。我们可以简单地使用os.mkdir()功能。
os.mkdir('test_dir')
让我们检查它是否工作。
但是，重要的是要知道创建一个已经存在的目录会导致异常。
因此，建议在创建之前始终检查是否存在。
if not os.path.exists('test_dir'):
os.mkdir('test_dir')
创建目录的另一个技巧。有时，我们可能希望创建两个或更多深度的子目录。如果我们仍然使用os.mkdir()，我们将需要多次这样做。这种情况下，我们可以用os.makedirs()。这个函数将创建所有的中间目录，就像 Linux 系统中的mkdir -p标志一样。
os.makedirs(os.path.join('test_dir', 'level_1', 'level_2', 'level_3'))
上面的代码创建了如下所示的目录树。
5.显示目录内容
另一个有用的功能是os.listdir()，它将显示一个目录的所有内容。它不同于os.walk()，后者将递归地显示目录“下”的所有内容。
大多数时候，我们可能只想循环一个目录中的文件，os.listdir()会更容易使用，因为它只是返回一个列表。
os.listdir('sample_data')
然而，有时我们可能想做一些高级搜索。例如，我们希望将所有 CSV 文件放在“sample_data”目录中。在这种情况下，最简单的方法是使用glob库，这也是 Python 内置的。
from glob import globlist(glob(os.path.join('sample_data', '*.csv')))
6.移动文件
现在，让我们在不同的位置之间移动一些文件。推荐的方式是使用shutil库。当然，它也是 Python 内置的。
假设我们想要将所有 CSV 文件从“sample_data”目录移动到我们在第 4 节中创建的“test_dir”目录。代码如下所示。
import shutilfor file in list(glob(os.path.join('sample_data', '*.csv'))):
shutil.move(file, 'test_dir')
肯定有更多不同的功能可以实现这一点。例如，如果你不想导入额外的库，我们仍然可以使用 OS 库。os.rename和os.replace都将帮助我们移动文件。
然而，缺点之一是这两个函数不够“智能”，不能让我们将文件移动到一个目录中。
为了让它工作，我们必须在目的地明确指定文件名。下面的代码将 CSV 文件移回“sample_data”目录。
for file in list(glob(os.path.join('test_dir', '*.csv'))):
os.rename(
file,
os.path.join(
'sample_data',
os.path.basename(file)
))
这里的函数os.path.basename()是从一个包含任意数量组件的路径中提取文件名。
另一个功能os.replace()将完全相同。然而，区别在于os.replace()是独立于平台的，而os.rename()只能在 Unix/Linux 系统上工作。
另一个缺点是 OS 库的这两个函数不支持从不同的文件系统移动文件，但是shutil支持。
因此，强烈建议使用shutil.move()来移动文件，以便让您的应用程序在不同的场景中表现一致。
7.复制文件
同样，当我们因为类似的原因需要复制文件时，推荐使用shutil。
如果我们想将README.md从“sample_data”目录复制到“test_dir”目录，函数shutil.copy()会有所帮助。
shutil.copy(
os.path.join('sample_data', 'README.md'),
os.path.join('test_dir')
)
这个函数的一个提示是，它可以在复制文件后对其进行重命名。只需将新名称作为第二个参数传递。
shutil.copy(
os.path.join('sample_data', 'README.md'),
os.path.join('test_dir', 'README(1).md')
)
8.删除目录或文件
最后但同样重要的是，我们有时需要删除文件或目录。OS 库大部分时候就够用了。
当我们想删除一个文件时，应该使用os.remove()。
os.remove(os.path.join('test_dir', 'README(1).md'))
当我们想删除一个目录时，os.rmdir()就可以了。
os.rmdir(os.path.join('test_dir', 'level_1', 'level_2', 'level_3'))
但是，它只能删除空目录。在上面的截图中，只能删除level_3目录。如果我们想递归删除目录level_1该怎么办？在这种情况下，我们再次需要来自shutil库的帮助。
功能shutil.rmtree()将完成这一任务。
shutil.rmtree(os.path.join('test_dir', 'level_1'))
记住要小心使用它，因为它会递归地删除目录中的所有内容。
摘要
在本文中，我介绍了 8 种基本的文件系统操作，以及如何使用 Python 实现它们。它们被认为是必不可少的，因为它们是处理多个文件的任何 Python 自动化任务的“构建块”。
同样重要的是要知道，有些功能是依赖于平台的，而有些则不是。以良好的方式编写代码对于任何可靠的应用程序都是至关重要的。
所有的源代码都在公开的 Google Colab 笔记本上，可以随时运行。
https://colab.research.google.com/drive/104ryrhopuEbMRrV6mwfh_BZxUFisnod1?usp=sharing https://medium.com/@qiuyujx/membership
如果你觉得我的文章有帮助，请考虑加入 Medium 会员来支持我和成千上万的其他作者！(点击上面的链接)
数据科学家和工程师必须知道的 8 个 venv 命令
探索一些对 Python 日常编程最有用的虚拟环境命令
介绍
Python 应用程序通常使用标准包库中不包含的第三方模块和包。此外，正在开发的软件包可能需要另一个库的特定版本才能正常工作。
这意味着一些应用程序可能需要一个特定的包版本(比如版本1.0)，而其他应用程序可能需要一个不同的包版本(比如2.0.1)。因此，我们将以冲突结束，因为安装两个版本中的任何一个都会导致需要不同版本的包中的问题。
在今天的文章中，我们将讨论如何使用虚拟环境来处理这个问题。此外，我们将探索一些最常用的命令，帮助您创建、使用和管理 Python 虚拟环境。
什么是虚拟环境
虚拟环境是一个自包含的目录，带有特定的 Python 版本和用户指定的附加包。此外，一旦虚拟环境被激活，用户就可以安装或卸载任何 Python 库(使用pip)。
Python 版本(默认情况下将包括安装在您的操作系统上的版本，除非您明确指定不同的版本)，安装在一个虚拟环境中的附加库和脚本，与安装在您的机器或任何其他虚拟环境中的那些完全隔离。
Python 附带了一个虚拟环境管理器，对于 Python 3 叫做venv，对于 Python 2 叫做virtualenv。在本文中，我们将展示如何使用venv，它是在环境中管理 Python 包的最底层工具。[venv](https://docs.python.org/3/library/venv.html)模块包含可用于支持创建和管理轻量级虚拟环境的功能。
用于日常编程的 8 个 venv 命令
在接下来的章节中，我们将讨论每个 Python 开发者都必须知道的 8 个常用的venv命令。请注意，强烈建议您为每个 Python 项目创建一个单独的虚拟环境，在其中您将能够安装和管理所有必需的依赖项。
1.创建虚拟环境
在开发自己的 Python 应用程序或库时，您需要做的第一件事是创建一个虚拟环境。
$ python3 -m venv my_venv
上面的命令将创建一个名为my_venv的虚拟环境，它位于当前目录下。现在，如果您检查创建的目录的内容，结果应该类似于下面所示
$ ls my_venv
bin/ doc/ etc/ images/ include/ lib/ pyvenv.cfg share/
如果您想在一个特定的目录下创建一个虚拟环境，那么只需将它和 venv 名称包含在一起。举个例子，
python3 -m venv path/to/your/venv/my_venv
2.激活虚拟环境
现在您已经创建了一个虚拟环境，您需要通过首先激活来指示您的操作系统使用它。为此，您需要调用activate脚本，该脚本位于您的虚拟环境的树结构中的bin/子目录下。
$ source my_venv/bin/activate
现在你应该注意到，在终端中，每一行都以(my_venv)开始，这表示当前名为my_venv的虚拟环境被激活。
一旦虚拟环境被激活，您安装或卸载的所有内容将只在该特定环境中生效，在其他地方不起作用。
3.停用虚拟环境
现在，如果您需要停用一个虚拟环境(假设您已经完成了您的包的开发，并且您可能需要在另一个上工作)，您可以通过在命令行中运行deactivate来这样做(这是一个内部实现细节)。
$ deactivate
现在您应该注意到名为的虚拟环境(用括号括起来，如(my_venv))已经消失了，这意味着当前没有活动的虚拟环境。
4.移除/删除虚拟环境
虚拟环境实际上只不过是一个自动创建的包含特定内容的树形目录。因此，为了去掉一个venv，你只需要从磁盘上删除这个目录。
$ rm -rf /path/to/my_venv
5.清除现有的虚拟环境
有时，您可能不想完全删除虚拟环境，而是希望清除以前安装的所有软件包。如果是这样的话，那么你只需要clear这个venv就可以了。为此，只需运行
$ python3 -m venv --clear path/to/my_venv
6.更新 Python 版本
现在，如果您想指示环境使用现有的 Python 版本，假设它已经就地升级，那么只需提供--upgrade标志:
$ python3 -m venv /path/to/my_venv --upgrade
7.允许虚拟环境访问系统站点包
正如已经强调的，安装在虚拟环境中的依赖项与安装在实际系统或任何其他环境中的相应包是隔离的。
现在，如果出于任何原因，你想让你的虚拟环境访问系统站点包目录，那么只需指定--system-site-packages标志来指示venv这样做。请注意，这不是一个推荐的做法，您应该只在真正需要时才使用它。
$ python3 -m venv /path/to/my_venv --system-site-packages
8.跳过 pip 安装
如果出于某种原因你想跳过pip(默认的软件包管理器)的安装和/或升级，那么你可以通过传递--without-pip标志来实现。
$ python3 -m vevn /path/to/my_venv --without-pip
最后的想法
在今天的文章中，我们讨论了在开发 Python 包时创建和使用虚拟环境的重要性。此外，我们还探讨了一些最常用的venv命令，为了正确创建、使用和管理您的虚拟环境，您应该了解这些命令。
通过运行 help 命令，您可以找到使用venv时所有选项的更全面列表:
$ python3 -m venv -h
成为会员 阅读介质上的每一个故事。你的会员费直接支持我和你看的其他作家。
你可能也会喜欢
</14-must-know-pip-commands-for-data-scientists-and-engineers-a59ebbe0a439> </16-must-know-bash-commands-for-data-scientists-d8263e990e0e>
熊猫教程强调了 8 个基本功能
关于您将在每个项目中使用的函数和代码的教程
由 CHUTTERSNAP 在 Unsplash 上拍摄的照片
无论您有一个杂乱的数据集需要清理和分析，还是想要为机器学习模型准备数据，pandas 都是您的图书馆。它使用简单，快速，非常直观。
Pandas 的是专门为数据科学而创作的，并且打包了来自其他库的附加特性。这意味着你只能在 pandas 中工作，而不能导入其他库，我们将在文章中看到。
熊猫的一个很大的缺点是它在大数据上失败了。这是因为 pandas 将其数据结构存储在 RAM 中，随着数据大小的增加，RAM 可能会耗尽内存。为此，使用 PySpark 或 Dask 。
要开始在 Jupyter 笔记本中使用 pandas，首先要将库导入到当前运行时。我们提供了一个别名pd，我们将在代码中引用它。
import pandas as pd
我们将使用来自 Kaggle 的谷物数据集进行演示。我们先来定义一些教程中反复使用的常用词。
- DataFrame —一个带有标签列和标签行的二维表格。这是熊猫的数据结构之一。
- 系列 —一列值及其索引。它也是一种数据结构。DataFrame 是 Series 对象的集合。
- 索引 —数据帧或系列中每一行(观察值)的标签。我们将索引称为行标签，它通常位于数据帧或系列的第一列。
- 列名 —数据帧中每一列的标题。
- 特征 —数据框中的一列。
第一部分。数据理解
1。将数据读入 Jupyter 笔记本
Pandas 可以读取一系列文本、二进制和 SQL 文件来返回 pandas 对象，该对象通常是 Dataframe。
我们使用pandas.read_csv()读取文本文件。该文档解释了要包含的几个可选参数，比如要在顶部跳过多少行(skip_rows)、要加载哪些列(usecols)以及要用作索引的列(index_col)。
pd.read_csv('file.csv')
其他数据加载功能有pd.read_excel()、pd.read_json()和pd.read_sql()。
2。查看数据
加载数据集后，您可以查看其内容。
df.head()、df.tail()和df.sample()分别显示前 5 个观察值、后 5 个观察值和一个随机选择的观察值。每个函数为行数选择一个可选的n参数，例如df.sample(5)。
df.head() #the first 5 rows
df.tail() #the last 5
df.sample() #one random row
作者图片
df.columns和df.index分别以列表形式返回列名和行索引值。
df.columns##Results
Index(['name', 'mfr', 'type', 'calories', 'protein', 'fat', 'sodium', 'fiber', 'carbo', 'sugars', 'potass', 'vitamins', 'shelf', 'weight', 'cups', 'rating'], dtype='object') df.index###Results
RangeIndex(start=0, stop=77, step=1)
注意我们的指数值显示它是一个 RangeIndex 。这是在没有指定列作为索引的情况下加载数据帧时创建的默认索引。它由从 0 到总行数的整数组成，在我们的例子中是 77 行。
在下面的代码中，我们使用pd.read_csv(filename, index_col). 显式地将“name”列设置为索引，也可以使用df.set_index(‘name’)。
df2 = pd.read_csv('cereal.csv',
**index_col='name'**)print(df2.index)###Results
*Index(['100% Bran', '100% Natural Bran', 'All-Bran',
'All-Bran with Extra Fiber', 'Almond Delight',...*
现在，所有索引值都显示为一个列表。
3。了解数据
熊猫让我们了解数据帧的结构和它所包含的信息类型。
df.shape返回一个元组来表示行数和列数。在我们的例子中，有 77 行和 16 列。
df.shape
*(77, 16)*
df.dtypes返回每列的数据类型。我们看到我们混合了分类(object)和数字(int 和float)特征。
作者图片
df.info()返回有关数据的信息，如列计数、每列中值的数量(非空意味着不为空或不缺失)以及它们的数据类型。
作者图片
df.describe()返回每个数字特征的描述性统计。在这里，我们得到每一列的值的数量(计数)、平均值、标准偏差和百分位数。
作者图片
使用 df.describe(include=’object’)返回分类(对象)列的描述性统计数据。我们得到每一列中唯一类别的数量、最常见的类别及其出现的次数。
作者图片
您还可以获得关于 DataFrame 或 Series 对象的单个统计信息。本文档展示了max()和mean()等聚合函数，以及cumsum()等元素操作。
4。通过选择查看数据
使用方括号[]选择列
df[‘rating’]选择“评级”栏。返回一个系列对象。
0 68.402973
1 33.983679
2 59.425505
3 93.704912
4 34.384843
...
df[[‘name’, ‘calories’, ‘rating’]]选择三列。请注意双括号[[。内括号用于保存列的列表，而外括号用于索引和返回列。返回一个数据帧。
df.loc[]按名称选择数据
df.loc允许您选择要显示的行和列。这些参数是索引的名称和(或)列。
df.loc[0, ‘name’]在“名称”列下显示索引 0 处的值。
df.loc[1:4, ‘protein’:’sugars’]返回从索引 1 到 4 的行，以及“蛋白质”和“糖”之间的所有列。冒号的使用意味着一个范围。注:范围内的两个值(开始和结束)都包含在结果的中。
作者图片
df.loc[[1,4], [‘name’,’calories’]]仅返回第 1 行和第 4 行，以及“姓名”和“卡路里”列。行和列在一个列表中，因此只返回这些，而不是一个范围。
作者图片
df.loc[:, :]返回所有行和所有列。注意:一个完整的冒号从头到尾返回所有内容。把冒号前或冒号后的空想象成“结束”。例如[:5]表示从一个‘端’到索引 5，而[5:]表示从索引 5 到‘端’。
df.iloc[]按位置选择数据
这里，我们提供行和(或)列的位置。把它想成‘索引位置’，所有位置都从 0 开始。注:在范围的情况下，结束值(finish)是从结果中排除的。
df.iloc[[3,5,16], [3,4,5]]返回索引为 3、5 和 16 的行以及位置为 3、4 和 5 的列。
作者图片
df.iloc[1:3, 2:4]返回从第 1 行到第 3 行、第 2 列到第 4 列的范围，不包括索引 3 和第 4 列。
type calories
1 C 120
2 C 70
df.iloc[[0,2], -3:]返回第 0 行、第 2 行和最后 3 列。-3:表示“从倒数第三列返回到最后一列”。
作者图片
根据数据类型选择列
df.select_dtypes()根据参数include=dtype 或exclude=dtype返回特定数据类型的列。
df.select_dtypes(include=’object’)仅返回包含字符串值的列。include=’number’返回整数和浮点数。
作者图片
df.select_dtypes(exclude=[‘float’,’int’])返回除以外的所有列，其值为floats 或ints。更多选项在本文档中。
根据条件选择数据
这使您能够选择满足特定条件的数据，例如年龄在 18 到 24 岁之间的所有学生。这也被称为布尔索引。
首先你创建一个遮罩，这是应该满足的条件。然后将蒙版应用到方括号[]内的数据框，就像我们选择列时所做的那样。这里我们索引并返回一个条件。
下面的代码显示评分高于 70 的所有谷物。
mask = df['rating'] > 70
df[mask]
作者图片
这些是德国生产的谷物。也可以使用df[‘mfr’] == ‘G’
mask = df['mfr'].isin(['G'])
df[mask]
这些是卡路里在 100 到 150 之间的谷物。在这里，你也可以使用(df[‘calories’] >= 100) & (df[‘calories’] <= 150)。
mask = df['calories'].between(100,150)
df[mask]
注意:要否定一个条件并返回相反的结果，请在掩码前包含波浪号~符号。
这里是所有名字中没有“小麦”的谷物。
mask = **~**df['name'].str.contains('wheat', case=False)
df[mask]
第 2 部分:可视化数据
数据可视化包括从数据中绘制图表和图形。像离群值、稀疏类和偏斜特征这样的细微见解，使用图表比我们之前使用的普通数字更容易发现。
您可以使用熊猫来绘制系列或数据框对象。Pandas 默认在后端使用 matplotlib，但是后面的剧情不需要导入 matplotlib 库。
5。制作基本情节
线条图。 这是默认的熊猫图，它显示数据在整个数据集中每一列的变化情况。y 轴是数据集中所有观察值的数字行，在我们的例子中是 0 到 77 行。然后，对于每个数字特征，绘制点，并绘制一条穿过所有点的线。
df.plot()
作者绘制的线图
我们看到钠和钾的含量最高，某些谷物的含量超过 300。
直方图。 显示数值特征中数值的分布，或数值的变化程度。我们包括参数kind=’box’并且也旋转轴。
df.plot(kind='box', rot=45)
作者的箱线图
同样，我们看到钠和钾在不同的谷物中变化很大，一些谷物含钠 300，而另一些谷物含钠 0。
散点图。 这显示了两个数字特征如何通过绘制它们的关系而一起移动。我们必须提供x,y,和kind参数。
df.plot(x = 'calories', y ='sugars' ,kind='scatter')
作者散点图
我们看到糖和卡路里之间的正相关。
酒吧剧情。 显示数字特征如何分布在分类特征中。在下面的代码中，我们修改了数据帧，将索引设置为“name ”,然后使用df.T翻转列和行(转置),稍后将介绍。
按作者转置的数据框架
df_t = df.set_index('name').T
df_t.iloc[[2,4,6,8,10,-1], :5].plot(kind='bar')
接下来，我们使用df.iloc选择行(矿物质和等级)来分析前 5 种谷物。注意评分最高的谷类食物是如何含有最少的卡路里、脂肪和糖，以及最高的纤维含量的。
作者的条形图
您可以使用 pandas 创建的其他图是区域图、 hexbin 图和饼图。
Pandas 提供了基本的格式化选项，例如移除图例、更改 x 和 y 标签、旋转轴标签以提高可读性，以及创建支线剧情。
然而，这些图看起来并不令人惊讶，你可以使用 matplotlib 、 seaborn、和这里提到的的其他库来进一步扩展 pandas 的功能。
第 3 部分:操作数据
6。重命名列和行索引
有时，您希望更改部分或全部列名，以使它们具有可读性。没有标题的数据帧需要一组全新的列名。
重命名列
要更改特定的列名，使用df.rename(columns=dict).。dict 参数包含需要重命名的列的“旧名称”到“新名称”的映射。
df.rename(columns =
{'mfr': 'manufacturer',
'potass': 'potassium'})
要更改所有列名，使用df.columns=list.该列表包含所有列的名称。
df3.columns = ['name', 'mfr', 'type', 'calories', 'protein', 'fat', 'sodium', 'fiber', 'carbo', 'sugars', 'potass', 'vitamins', 'shelf', 'weight', 'cups', 'rating']
重命名行索引
使用了相同的函数df.rename(index=dict)，但是使用了index参数。字典是一个“旧索引名”对的字典。
df.rename(index={0:1000,
1:1001})
要同时重命名索引和列名，请在df.rename函数中包含index和column参数。
7。删除和插入数据
添加一列
我们将从四个方面来看，但是首先让我们创建一个包含新列中的值的列表。值的数量必须等于它填充的行数，否则会导致 ValueError 。
import numpy as nprand_list = np.random.randint(0, 20, len(df))
我们使用 numpy 库来创建范围在 0 到 20 之间的随机整数，值的数量将等于行数。
方法一:df['col'] = values
这里，我们引用方括号中的新列名，然后使用等号(=)来赋值。此方法也可用于替换现有列的值。
df['new_col'] = rand_list
默认情况下，此新列显示为最后一列。
方法二:df.loc[:, column_name] = values
还记得我们之前看的.loc函数吗？第一部分引用行(and:表示所有行)。逗号后面的第二部分引用新列。然后我们赋值，新列出现在最后一个位置。
df.loc[:, 'new_col'] = rand_list
方法三:df.insert(location, column_name, values)
这里，我们使用.insert并提供我们想要插入列的位置(position )(位置从 0 开始计数)、列名和要填充的值。如果提供了一个值，则用它填充整个列。
df.insert(1, 'new_col', rand_list)
作者图片
注意，该方法就地修改原始数据帧而不制作副本。
方法四:df.assign(col_name=values)
这个方法返回一个修改过的数据帧，而不改变原来的数据帧，然后将这个修改过的副本赋给 df 变量。新列出现在最后一个位置。
df = df.assign(new_col = rand_list)
插入一行
使用类似于上面创建列的方法二的df.loc[index_name] = values。首先，我们创建一个值列表来填充新行。
row_list = ['Awesome Oats', 'K', 'C', 100, 3, 1, 180, 2.0, 15.0, 5, 40, 25, 3, 1.0, 0.63, 75.345423]
然后我们使用df.loc[name]来指向那个索引，如果它不存在就创建它。然后我们使用赋值操作符(=)来赋值。
df.loc[77] = row_list
作者图片
要一次添加几行，您可以用新行创建一个新的数据框，并使用pd.concat(df, df_new)或df.append(df_new)。
移除(删除)一列
使用 df.drop(columns=cols)删除一列或多列。
df.drop(columns='sodium', inplace=True)
这段代码删除了‘sodium’列。inplace=True就地修改原始数据帧，否则保留原始数据帧并返回修改后的 df。
删除一行
使用df.drop(index=row_index)删除一行。查看此处的文档了解更多参数。
df.drop(index=76)
改变列顺序
方法 1: df[[col2, col1, col5, col3]]内部的方括号包含所需顺序的列名。
new_order = np.random.choice(col_list, 16)df = df[new_order]
按作者排序的列的图像
方法 2: df.reindex(columns=col_list). 这个函数接受要返回的列名列表。
df.reindex(columns = new_order)
您可以使用这两种方法中的任何一种来分割数据帧并返回较少的列。
翻转列与行(转置)
我们使用df.transpose()或df.T函数来交换行和列。例如，假设我们希望将谷物的名称作为特性，将特性作为行索引。
首先我们使用df.set_index来设置名称作为索引。
作者图片
然后我们调用df2.T来转置索引和列。
转置数据帧 bu 作者
8。分类数据
可以对一列(Series 对象)中的值进行排序，也可以按列对整个数据帧进行排序。
排序一列
对“名称”列进行排序，并返回一个系列对象。参数ascending=False按降序排序。
按作者排序的列
df.sort_values(‘name’)返回按‘name’列排序的整个数据帧。必须提供参数by=。
排序指标:
df[‘name’].sort_index()按索引对“名称”列进行排序(下面的 0 到 4)。
df2.sort_index(ascending=False)按索引降序排列整个数据帧。当索引是日期时，这尤其有用。
结论
在本教程中，我们使用 pandas 库进行数据分析和操作。我们还研究了一些可视化技术，以及如何使用额外的库来扩展它们的功能。
这绝不是熊猫的详尽视图，文档提供了深入的代码和功能。我鼓励您使用这里共享的代码片段的几种变体进行实践，并尝试几个参数。只有这样做，你才能了解熊猫的全部力量。
所有使用的代码都是 GitHub 上的这里。感谢您的阅读！
数据科学的 8 个 Python 片段
詹姆斯·哈里森在 Unsplash 上的照片
常见数据科学问题的快速解决方案
我喜欢定期查看我的数据库，里面有对数据科学有用的 python 代码片段，让简单的解决方案永远留在我的脑海里。
在本文中，我将分享 8 个 Python 片段，以方便您的数据科学工作流程
1.获取熊猫数据帧的内存使用情况
这里我们使用 pandas 的.memory_usage()方法来获得 pandas 数据帧的字节大小，然后将其转换为兆字节
import pandas as pd
import numpy as np
df = pd.DataFrame(dict(a=list(range(1000)), b=np.random.random(1000)))
BYTES_TO_MB_DIV = 0.000001
mem = round(df.memory_usage().sum() * BYTES_TO_MB_DIV, 3)
print(mem, "MB")0.016 MB
2.制作熊猫列小写字母
这里我们创建一个简单的 dataframe，然后使用 pandas .str.lower()方法将列中的所有字母变成小写
from string import ascii_letters
import pandas as pddf = pd.DataFrame(dict(letters=np.random.choice(list(ascii_letters), 1000), numbers=np.random.randint(0,1000,1000)))
df["letters"] = df["letters"].str.lower()
df["letters"]# Output0 m
1 y
2 s
3 c
4 l
..
995 o
996 q
997 w
998 s
999 u
Name: letters, Length: 1000, dtype: object
3.使用装饰器分析代码
在这里，我们使用 cProfile 包通过一个简单的装饰器来分析一个函数
import cProfile
def testPerformance(func):
def wrapper(x):
print(cProfile.run(f"{func(x)}"))
return wrapper
@testPerformance
def printLoop(n):
for i in range(n):
print(i)
printLoop(100)# Output0
1
2
3
4
5
6
7
8
9
10
.
.
.
99
3 function calls in 0.000 seconds
Ordered by: standard name
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.000 0.000 0.000 0.000 <string>:1(<module>)
1 0.000 0.000 0.000 0.000 {built-in method builtins.exec}
1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects}
None
4.将函数映射到列表元素
这里我们使用map()内置方法将str.upper()方法映射到一个字母列表
from string import ascii_letters
letters = list(ascii_letters)
newlist = list(map(str.upper, letters))
newlist['A',
...
'O',
'P',
'Q',
'R',
'S',
'T',
'U',
'V',
'W',
'X',
'Y',
'Z']
5.基于列表中的值过滤数据帧
这里，我们将列表中的值与熊猫列中的值进行匹配
df = pd.DataFrame(dict(a=np.random.randint(0,100,100)))
values = np.random.randint(0,50,50)
df.loc[df['a'].isin(values)]
6.用 matplotlib 从字典中绘图
这里我们使用 matplotlib 直接从字典中绘制数据。
# source: matplotlib documentation
data = {'a': np.arange(50),
'c': np.random.randint(0, 50, 50),
'd': np.random.randn(50)}
data['b'] = data['a'] + 10 * np.random.randn(50)
data['d'] = np.abs(data['d']) * 100
plt.scatter('a', 'b', c='c', s='d', data=data)
plt.xlabel('entry a')
plt.ylabel('entry b')
plt.show()
7.在 matplotlib 中使用文本和箭头进行注释
在这个改编自 matplotlib 文档的例子中，我们使用plt.annotate()用箭头和文本注释了一个图形
# adapted from: https://matplotlib.org/stable/tutorials/text/annotations.html
ax = plt.subplot()
t = np.arange(0.0, 10.0, 0.01)
s = np.cos(2*np.pi*t)
line, = plt.plot(t, s, lw=2, color="green")
plt.annotate('local max', xy=(2, 1), xytext=(3, 1.5),
arrowprops=dict(facecolor='black', shrink=0.05),
)
plt.annotate('local min', xy=(3.5, -1), xytext=(3, -1.5),
arrowprops=dict(facecolor='black', shrink=0.05),
)
plt.ylim(-2, 2)
plt.show()
输出
8.格式化日期。join()和日期时间
from datetime import datetime
date = datetime.now()
date = "-".join([str(date.year),str(date.month),str(date.day)])
print(date)# Output
'2021-9-15'
关于数据科学片段的结束语
对于任何想要优化工作流程的数据科学家来说，保持一个更新的快速片段列表来解决简单的问题是必须的。在这篇文章中，我试图分享一些在某个时候对我有帮助的快速解决方案。
如果你对数据科学感兴趣，可以看看这个 Udacity 纳米学位项目:
这是一个附属链接，如果你使用该课程，我会得到一小笔佣金，干杯！😃
如果你喜欢这篇文章，在媒体、上关注我，订阅我的时事通讯，在推特、 LinkedIn 、 Instagram ，或者加入媒体！谢谢，下次再见！😃
用熊猫操纵指数的 8 个快速技巧
提高你的熊猫技能
杰弗里·沃克曼在 Unsplash 上拍摄的照片
如果您使用 Python 作为数据处理语言，那么 pandas 很可能是您的代码中使用最多的库之一。pandas 中的关键数据结构是 DataFrame，这是一个类似电子表格的数据表，由行和列组成。当我们处理数据帧时，我们经常需要处理索引，这可能很棘手。在本文中，让我们回顾一些关于处理熊猫指数的快速技巧。
1.读取时指定索引列
在许多情况下，我们的数据源是一个 CSV 文件。假设我们有一个名为data.csv的文件，它包含以下数据。
date,temperature,humidity
07/01/21,95,50
07/02/21,94,55
07/03/21,94,56
默认情况下，pandas 将为我们的行创建一个基于 0 的索引，如下所示。
>>> pd.read_csv("data.csv", parse_dates=["date"])
date temperature humidity
0 2021-07-01 95 50
1 2021-07-02 94 55
2 2021-07-03 94 56
然而，我们可以通过将参数index_col设置为适用的列，在导入过程中直接指定索引列。
>>> pd.read_csv("data.csv", parse_dates=["date"], **index_col**="date")
temperature humidity
date
2021-07-01 95 50
2021-07-02 94 55
2021-07-03 94 56
2.使用现有数据框架设置索引
在读取数据或一些其他数据处理步骤之后，您可能想要手动设置索引。我们可以使用set_index方法。
>>> df = pd.read_csv("data.csv", parse_dates=["date"])
>>> df.set_index("date")
temperature humidity
date
2021-07-01 95 50
2021-07-02 94 55
2021-07-03 94 56
在此方法中，您指定哪些列将成为新索引。有两件事值得注意。
- 默认情况下，该方法将创建一个新的数据帧。如果您想就地改变索引，您可以运行
df.set_index(“date”, inplace=True)。 - 如果想保留设置为索引的列，可以运行
df.set_index(“date”, drop=False)。
>>> df.set_index("date", drop=False)
date temperature humidity
date
2021-07-01 2021-07-01 95 50
2021-07-02 2021-07-02 94 55
2021-07-03 2021-07-03 94 56
3.在一些操作后重置索引
当您处理数据帧时，一些操作，如删除行、索引选择，会产生原始索引的子集。要重新生成连续的索引，可以使用reset_index方法。
重置索引
通常情况下，我们不需要保留旧索引，所以我们希望将drop参数设置为True，这意味着该操作将删除旧索引。以类似的方式，如果您想就地重置索引，不要忘记将inplace参数设置为True，否则将创建一个新的数据帧。
4.通过 groupby 操作将索引转换为列
groupby方法用途广泛，有多种应用。例如，让我们继续使用我们在上一步中创建的df0 DataFrame，添加一个分组列。
分组索引
使用分组变量和列作为索引，创建的数据帧不一定是您需要的数据帧。相反，您可能希望这些索引是列。有两种方法可以完成所需的操作，如下所示。就我个人而言，我更喜欢第二种方法，它只包含两个步骤。
>>> df0.groupby("team").mean().reset_index()
team A B C
0 X 0.445453 0.248250 0.864881
1 Y 0.333208 0.306553 0.443828
>>> df0.groupby("team", as_index=False).mean()
team A B C
0 X 0.445453 0.248250 0.864881
1 Y 0.333208 0.306553 0.443828
5.排序后重置索引
排序是数据处理过程中非常常见的操作。当我们对行进行排序时，默认情况下，行将保持它们各自的索引。然而，这可能不是我们想要的行为。如果要在排序后重置索引，只需在sort_values方法中设置ignore_index参数即可。
排序后重置索引
6.删除重复项后重置索引
当我们处理现实生活中的数据集时，经常会出现重复记录的情况。因此，我们需要删除这些重复项。删除后，我们还希望索引按所需的顺序排列(例如，升序、增量)。使用类似的方法，我们可以利用 drop_duplicates 方法中的ignore_index参数。
为了简单起见，让我们假设每个团队对于df0数据帧应该只有一个记录。
>>> df0
A B C team
0 0.548012 0.288583 0.734276 X
1 0.342895 0.207917 0.995485 X
2 0.378794 0.160913 0.971951 Y
3 0.039738 0.008414 0.226510 Y
4 0.581093 0.750331 0.133022 Y
>>> df0.drop_duplicates("team", ignore_index=True)
A B C team
0 0.548012 0.288583 0.734276 X
1 0.378794 0.160913 0.971951 Y
如上所示，在通过“team”列删除重复项后，只有每个团队的第一条记录保留在生成的数据帧中。重要的是，因为我们将ignore_index设置为True，新的 DataFrame 以基于 0 的方式使用一组新的索引。
7.指数的直接分配
当您有一个现有的数据帧时，您可能需要用不同的数据源或通过单独的操作来分配索引。在这种情况下，您可以直接将索引分配给现有的数据帧。
>>> better_index = ["X1", "X2", "Y1", "Y2", "Y3"]
>>> df0.index = better_index
>>> df0
A B C team
X1 0.548012 0.288583 0.734276 X
X2 0.342895 0.207917 0.995485 X
Y1 0.378794 0.160913 0.971951 Y
Y2 0.039738 0.008414 0.226510 Y
Y3 0.581093 0.750331 0.133022 Y
8.写入 CSV 文件时忽略索引
不是每个人都使用 Python 或 pandas，所以我们经常需要将数据导出到一个 CSV 文件中，以便共享。在许多情况下，数据帧具有从 0 开始的索引。但是，我们不希望它出现在导出的 CSV 文件中。在这种情况下，我们可以在to_csv方法中设置index参数。
>>> df0.to_csv("exported_file.csv", index=False)
导出的 CSV 文件将如下所示。如您所见，文件中不包含索引列。
导出的 CSV 文件没有索引
结论
在这篇文章中，我们回顾了熊猫最常见的索引操作。熟悉它们对你和熊猫的数据处理工作很有帮助。当然，我没有谈论多指数，这可以是未来文章的主题。
开始使用 Pydantic 改进数据解析和验证的 8 个理由
改善您的应用程序需要控制它们的数据质量
图片由作者提供—碳上制造. now.sh
在我之前的一篇文章中，我将数据类视为编写充当数据容器的 python 类的一种方式。
我发现 dataclasses 项目令人惊叹:它实现了许多漂亮的方法来防止您编写样板代码，它提供了简洁的 pythonic 语法，并且强制实施了现代编程实践。
然而，这个模块缺少的一个重要特性是数据验证:在运行时对数据实施模式约束的过程。
这就是 Pydantic 项目发挥作用的地方。
在本帖中，我们将介绍数据验证以及为什么在开发 Python 应用程序时应该考虑它。然后，我们将介绍 Pydantic libray 作为解决这个问题的一种方法。
我们将介绍它的 8 个有用特性，看看如何通过几行代码将它们快速嵌入到您的应用中。
一如既往:少说多做。让我们看一看🔍
什么是数据验证？
Diana Polekhina 在 Unsplash 上拍摄的照片
数据验证是使数据符合为每个属性定义的一组规则、模式或约束的过程。这使得您的代码按照预期的方式接收和返回数据。
数据验证可防止因用户输入格式错误等问题而出现意外错误。从这个意义上说，它也是一个净化过程。
让我们举个例子:想象一下，你正在构建一个信用评分 API 来评估一个人的信用度。
要使这个 API 工作，您必须在给定的 URL 上发送 post 请求，并提供一些有效载荷数据。
该数据定义了一个个体:它的一些字段是必需的，一些其他的是可选的。但这并不止于此。
出于某种原因，此人必须将法国税号作为必填字段的一部分。这个标识符遵循一定的模式:假设，它必须有 13 个数字，并且必须以 2 个大写字母结尾。
个人还必须提供一个完整的地址:它必须有一个街道名称、一个号码和一个邮政编码。邮政编码必须是由 5 位数字组成的。
这可以继续下去，但你看到了要点。
👉数据验证确保发送给 API 的数据遵循这些约束。
通过加载数据并对每个字段应用一系列条件，您仍然可以使数据遵循这些约束。这是可行的，但是随着时间的推移，它会很快导致大量代码变得不可维护。
如果我们可以将数据封装到一个类中，为它的每个字段创建一个类型化属性，并在运行时当数据加载到类中时验证字段约束，会怎么样？
嗯，Pydantic 可能是这个问题的确切答案。
什么是 Pydantic？
" Pydantic 是一个使用类型注释提供数据验证和设置管理的库."— Pydantic 官方文件。
我喜欢把 Pydantic 想象成你撒在食物上(或者在这种特殊情况下，你的代码库)使它味道更好的一点盐:Pydantic 不关心你做事的方式。它更像是一个抽象层，您可以在不改变代码逻辑的情况下将其添加到代码中。
如您所料，这一层将主要处理数据解析和验证，以及其他一些很酷的特性。
现在让我们来看一下 Pydantic 的 8 个特性，以理解它为什么如此有用。
1 —定义数据模型的简单语法
您可以在从BaseModel类继承的类中定义您的数据。
Pydantic 模型是接收数据、解析数据并确保数据符合数据中定义的字段约束的结构。
让我们从一个简单的例子开始，这里我们定义了一个Person类，它有两个没有任何约束的字段:first_name和last_name。
- 就像数据类一样，我们使用类型注释。
- 与数据类不同，我们不使用@dataclass 装饰器。相反，我们从
BaseModel类继承
通过调用typing模块，我们可以添加更复杂类型的字段。
您甚至可以创建本身就是 BaseModel 类的类型。
如果您想了解 Pydantic 如何与 FastAPI 等流行库耦合，可以看看我之前关于这个主题的帖子。
2 —用户友好的错误信息
当您定义一个 Pydantic 模型并且向它传递一些不符合定义的模式的数据时会发生什么？
为了理解 Pydantic 在这种特殊情况下的行为，让我们来看看这个简单的模型:
现在让我们输入一些不一致的数据，看看会返回什么样的错误消息。
❌第一个案例:缺少必填字段:
让我们省略age字段。这立即抛出一个ValidationError,指向特定的缺失字段。
作者图片
❌第二种情况:字段类型不一致
不要向age字段传递一个整数，而是传递一个字符串:例如"30 years"而不是30。
类似地，这抛出了一个ValidationError，消息明确声明该字段需要一个整数类型。
作者图片
👉值得一提的是，Pydantic 总是试图强制您注释的类型。例如，如果您试图将“30”传递给age字段，即使该字段需要一个整数值，它仍然可以工作。Pydantic 现成地处理了这种情况。
作者图片
👉通过导入ValidationError类并在 try / except 语句中调用它，可以使 Pydantic 错误消息更加明确。
3—与 ide 和 linters 的良好集成
Pydantic 与现代 ide(如 VSCode 和 PyCharm)集成得很好。这有助于您快速调试代码，避免愚蠢的错误。
例如，当您从 Pydantic 模型中实例化一个对象时，您会立即拥有自动完成功能。
IDE 中的自动完成功能—作者截图
你也有林挺，假设你使用静态类型检查器，比如 mypy 。
在下面的例子中，如果您试图将len函数应用于age属性，VSCode 将通过 mypy 发出错误信号。
林挺与 MyPy——作者截图
4—现场定制
Pydantic 允许您通过将字段包装在Field类中，在每个字段上添加一些验证。
例如:
- 您可以通过使用字段的
max_length和min_length参数来添加对字符串字段长度的约束 - 您可以使用字段的
ge和le参数设置数值字段的边界。(ge:大于等于，le:小于等于)。
让我们看看下面的例子，我们在first_name(长度在 2 到 20 之间)和age(值小于 150)上添加了约束。
让我们看看，如果我们试图将下面的数据传递给 Person 类，会返回什么错误。
**data = {"first_name": "a", "last_name": "Besbes", "age": 200}**
自定义字段后出现错误—作者截图
您可以执行更高级的字段定制。这里有一些你可以在Field类中使用的参数
**regex**:增加一个正则表达式验证器。当您希望某些字符串值匹配特定模式时，这很有用**multiple_of**: 这适用于 int 字段。它添加了一个“多重”验证器**max_items**和**min_items**: 这适用于列表，并对列表中包含的项目数量进行限制**allow_mutation**: 这适用于任何类型的字段。它默认为 False。当设置为 True 时，它使字段不可变(或受保护)。
要了解更多关于 Pydantic 字段定制的可能性，请看文档中的这个链接。
5—许多辅助方法
你不必重新发明轮子。Pydantic 为您提供了许多可以使用的帮助函数和方法。让我们看一些例子:
从下面的代码开始，
让我们创建一个Person对象:
**data = {"first_name": "Ahmed", "last_name": "Besbes", "age": 30}
person = Person(**data)**
该对象可以访问许多有用的方法。
dict():从对象返回一个字典json():返回 JSON 格式的字典copy():返回对象的副本schema():打印 JSON 中的模式
Pydantic helper 函数—作者截图
要了解更多关于助手函数的信息，请看这个链接。
6 — Pydantic 类型
str、int、float、List是我们工作中常见的类型。
然而，在某些情况下，我们可能会处理需要特定验证的值，例如路径、电子邮件地址、IP 地址等等。
幸运的是，Pydatnic 为这些用例提供了一个内置类型列表，并且涵盖了:
- 文件路径:用于解析文件路径
- 目录路径:用于解析目录路径
- EmailStr: 用于解析电子邮件地址
- 颜色:用于解析 HTML 颜色(参见颜色类型)
- HttpUrl: 用于解析严格的 HttpUrl
- IPvAnyAddress :解析 IPv4 和 IPv6 地址
7-自定义验证器
Pydantic 允许您编写自己的自定义验证器。
假设我们想要将PhoneNumber字段添加到前面的示例中。
我们希望该字段遵守两个约束:
- 这是一串 10 位数
- 它必须以 0 开头
要执行自定义验证，您必须从 Pydantic 导入validator函数，并在测试字段值的函数之前将其用作装饰器。
自定义验证器—作者截图
当然，您可以进行更复杂的验证。看看这个链接了解更多。
8 —解析环境变量值
Pydantic 允许您从。并在BaseSettings类中直接解析它们。
为此，首先需要安装 python-dotenv。
(要了解更多关于 python-dotenv 和环境变量的内容，可以参考我之前关于该话题的 帖子)
假设你有一些环境变量在里面。环境文件:
**LOGIN=Ahmed
API_KEY=SeCR€t!
SEED=42**
为了让 Pydatnic 加载这些变量，我们首先必须定义一个继承自BaseSettings类的Settings类。
在Settings类中，我们将定义在。env 文件，同时添加类型和验证器。
最后，我们指定应该从. env 文件中读取环境变量。
如果我们运行代码，设置会被打印到终端上。
从加载环境变量。环境文件—作者截图
如果我们用 42 代替 42。env 文件，下面是我们得到的结果:
作者截图
很酷，对吧？
资源
Pydantic 是一个非常棒的工具，我非常喜欢学习和使用它。
如果你也有兴趣了解这个库的更多信息，这里有一个我精选的资源(博客文章和 Youtube 视频)的精选列表。
- Pydantic 官方文件
- https://dev . to/tiangolo/the-future-of-fastapi-and-pydantic-is-bright-3pbm
- 【https://dev.to/amal/pydantic-for-fastapi-2385
- https://dev . to/nazliander/using-pydantic-as-a-a-parser-and-data-validation-tool-51n 3
- https://dev . to/izabelakowal/some-ideas-on-how-to-implementation-DTOs-in-python-be3
- (一篇法国的博文):https://ichi . pro/fr/le-guide-du-debutant-sur-pydantic-204731199577737
- 来自 ArjanCodes Youtube 频道的一个伟大的 Pydantic 介绍(向这个在编程方面制作惊人视频的家伙大声欢呼)
- pydantic:Michael Kennedy 的现代 Python 数据验证和设置—一个精彩的视频教程
感谢阅读🙏
如果你坚持到最后，我真的感谢你的时间，并希望你发现这篇文章对开始使用 Pydantic 有用。
如果你不使用 Pydantic 并且知道一个更好的选择，请在评论中告诉我📥
今天就这些了。直到下一次更多的编程技巧和教程。👋
新到中？您可以每月订阅 5 美元，并解锁无限的文章— 单击此处。
开始机器学习之旅的 8 个推荐 Python 库
没有正确地学习它们，你会中途放弃！
切坦·科尔特在 Unsplash 上拍摄的照片
机器学习是这些天的热门话题之一。Python 是许多用户的首选编程语言。然而，Python 是一种通用编程语言，这意味着它被用于如此多的不同领域。要使用 Python 进行机器学习，除了通用 Python 之外，还需要学习一些额外的 Python 库。
在这篇文章中，我将讨论最基本的 Python 库的概述，这些库将帮助您开始机器学习之旅。我强烈建议你尽可能地熟悉它们，因为它们是根本。如果没有正确地学习它们，你会在学习的中途放弃！
1.NumPy
NumPy 是构建在 NumPy 之上的许多其他库的母库。NumPy 代表数字百分比 Py thon。 ndarray (N 维数组)对象是 NumPy 中的主要数据结构。在机器学习中，我们经常使用向量(1D 阵列)和矩阵(2D 阵列)。NumPy 提供了创建这些数组的简单方法。当处理图像数据时，我们处理 NumPy 3D 数组。NumPy 还提供了大量的数学函数，尤其是线性代数函数。
资源
作者截图
装置
默认情况下，NumPy 附带了 Anaconda 安装程序。如果您已经通过 Anaconda 安装了 Python，那么您不需要再次安装 NumPy。但是，有两种方法可以安装 NumPy。
康达安装
conda install -c anaconda numpy
#OR
conda install -c conda-forge numpy
pip 安装
pip install numpy
进口惯例
共同体接受的 NumPy 进口惯例是:
import numpy as np
2.熊猫
Pandas 是 Python 数据操作和分析库。它建立在 NumPy 之上，这意味着它支持 NumPy N 维数组。熊猫是如此受欢迎，它的下载总数可以代表整个数据科学社区！Pandas 提供了数据加载、数据清理、变量编码、数据转换等方法。Pandas 还提供绘图功能，因为它集成了各种绘图库。系列和数据帧是熊猫中的两种主要数据结构。Pandas 系列可以用一维 NumPy 数组创建，而 Pandas 数据帧可以用二维 NumPy 数组创建，因为 Pandas 是在 NumPy 之上构建的。
资源
作者截图
装置
Pandas 默认带有 Anaconda 安装程序。如果您已经通过 Anaconda 安装了 Python，那么您不需要再次安装 Pandas。但是，有两种安装熊猫的方法。
康达安装
conda install -c anaconda pandas
#OR
conda install -c conda-forge pandas
pip 安装
pip install pandas
进口惯例
共同体接受的熊猫进口惯例是:
import pandas as pd
3.Matplotlib
Matplotlib 是 Python 中的一个基本绘图库。但是，它为您的地块提供了大量的自定义选项。它也是其他高级绘图库的母库。该库有两个不同的应用编程接口(API)——py plot 接口和面向对象接口。
资源
装置
默认情况下，Matplotlib 附带了 Anaconda 安装程序。如果您已经通过 Anaconda 安装了 Python，那么您不需要再次安装 Matplotlib。但是，有两种方法可以安装 Matplotlib。
康达安装
conda install -c conda-forge matplotlib
pip 安装
pip install matplotlib
进口惯例
共同体接受的 Matplotlib 导入惯例是:
import matplotlib.pyplot as plt
4.海生的
Seaborn 是一个高级数据可视化库，这意味着它可以自动为我们做很多事情！也为你的剧情提供了很多审美。您可以使用 Matplotlib 自定义 seaborn。
资源
装置
Seaborn 默认带有 Anaconda 安装程序。如果您已经通过 Anaconda 安装了 Python，那么您不需要再次安装 Seaborn。但是，有两种方法可以安装 Seaborn。
康达安装
conda install -c anaconda seaborn
pip 安装
pip install seaborn
进口惯例
共同体接受的 Seaborn 进口公约是:
import seaborn as sns
5.sci kit-学习
Scikit-learn 是一个 Python 机器学习库。它的语法非常一致，即使是初学者，通过创建一两个模型也很容易熟悉整个库。它的官方文档提供了使用这个库所需的所有支持。它包括分类、回归、聚类、降维模型的算法。它还提供了数据预处理的高级方法。
资源
作者截图
装置
默认情况下，Scikit-learn 附带了 Anaconda 安装程序。如果您已经通过 Anaconda 安装了 Python，那么您不需要再安装 Scikit-learn。但是，有两种方法可以安装 Scikit-learn。
康达安装
conda install -c anaconda scikit-learn
#OR
conda install -c conda-forge scikit-learn
pip 安装
pip install scikit-learn
进口惯例
我们不会一次导入整个库。相反，我们在需要时导入类和函数。
6.黄砖
Yellowbrick 是一个机器学习可视化库。顾名思义，它适用于机器学习相关的可视化。语法非常类似于 Scikit-learn 库。使用 Yellowbrick，您只需一两行代码就可以创建高级的绘图！
资源
- 官方网站和文档
- 我自己的资源:我还为 Yellowbrick 发表了一系列文章:
作者截图
装置
默认情况下，Yellowbrick 没有附带 Anaconda 安装程序。因此，需要单独安装。有两种方法。
康达安装
conda install -c districtdatalabs yellowbrick
pip 安装
pip install yellowbrick
进口惯例
像 Scikit-learn 一样，我们不会一次导入整个库。相反，我们在需要时导入类和函数。
7.XGBoost
当我们考虑机器学习模型的性能时，XGBoost(极限梯度提升)是在数据科学家和机器学习工程师中最受青睐的机器学习算法。XGBoost(这次是库)可用于包括 Python 在内的许多编程语言。XGBoost 的 Scikit-learn 包装器(Scikit-learn 兼容 API)最近已经发布，这样我们就可以像 Scikit-learn 一样使用 XGBoostT5。还有一个与 Scikit-learn 不兼容的用于 XGBoost 的 API。然而，与 XGBoost 的Scikit-learn 包装器相比，它很难使用。所以我推荐你先用 XGBoost 的Scikit-learn 的包装器，然后再去用非 Scikit-learn 的版本(如果你愿意的话)。
资源
- 官网和文档
- 我自己的资源:我还为 XGBoost 发表了一系列文章:
作者截图
装置
默认情况下，XGBoost 没有附带 Anaconda 安装程序。因此，您需要使用以下代码单独安装它。
conda install -c anaconda py-xgboost #Windowsconda install -c conda-forge xgboost #MacOS or Linux
进口惯例
共同体接受的 XGBoost 进口惯例是:
import xgboost as xgb
8.张量流
TensorFlow 是为深度学习任务创建的深度学习库。深度学习是机器学习的一个子集。TensorFlow 也可以用于一般的机器学习。它有两个 API——高级 API 和低级 API 。它的主要数据结构是张量。
资源
- 官方网站和文档
- 我自己的资源:我还为 TensorFlow 发表了一系列文章:
作者截图
装置
默认情况下，TensorFlow 没有附带 Anaconda 安装程序。因此，需要单独安装。有两种方法。
康达安装
conda install -c conda-forge tensorflow #CPU-only
pip 安装
pip install tensorflow #Both CPU and GPU support
进口惯例
TensorFlow 的共同体公认进口惯例是:
import tensorflow as tf
我们应该按照什么顺序学习这些库？
按照上面的顺序！从 NumPy 基础知识和数组创建方法开始。然后执行 NumPy 数组索引和切片。熟悉它们之后，请转到熊猫基础——创建系列和数据框。现在，你可以进行并行学习 NumPy 和 Pandas 都可以。在这个阶段，熟悉 NumPy 算法和线性代数运算，并掌握高级理论—子集化、数据清洗、变量编码、数据转换等。然后，搬进马特普罗提卜和希博恩。就从 Matplotlib 开始吧。我建议您使用 Pandas 绘图功能进行基本的可视化。如果您需要更多的定制，请使用 Matplotlib。对于高级可视化，请使用 seaborn。现在，是时候学习 Scikit-learn 了。现在，这将是容易的，因为你熟悉熊猫和熊猫。当你熟悉 Scikit-learn 时，你可以使用 Yellowbrick 进行机器学习可视化。然后是 TensorFlow 和深度学习部分。通过这样做，你将永远不会在学习的中途放弃！
这些方法对你有用吗？在评论区告诉我。
感谢阅读！
下次见，祝大家学习愉快！
特别感谢 Unsplash 网站上的切坦·科尔特，为我提供了这篇文章的封面图片。
鲁克山普拉莫迪塔
2021–08–04
8+强化学习项目创意
想通过强化学习获得实用的实践经验吗？这里有一些启发你的项目想法。
这篇文章是强化学习(RL)项目想法的汇编。我尝试选择涵盖 RL 中一系列不同困难、概念和算法的项目。
1.用 OpenAI Gym 解决玩具问题(适合初学者)
来自 OpenAI 健身房的翻筋斗环境(作者截图)
OpenAI Gym 已经成为研究人员和实践者之间强化学习框架的事实标准。从健身房图书馆解决玩具问题将有助于你熟悉这个流行的框架和简单的 Q 学习算法。好的起点包括侧手翻、月球着陆器和滑行。
如果你对一步一步的演练感兴趣，可以看看我的关于 Taxi 的入门 Q-learning 教程。
2.使用 OpenAI Gym 从 pixel input 玩雅达利游戏
雅达利环境编译(图片由作者提供)
OpenAI Gym 还包含一套 Atari 游戏环境作为其街机学习环境(ALE)框架的一部分。例子包括越狱、蒙特祖马复仇和太空入侵者。
环境观察以屏幕输入或 RAM 的形式提供(直接观察 Atari 2600 的 1024 位内存)。解决 Atari 环境将需要使用更复杂的 RL 算法和深度学习库，如 TensorFlow 或 PyTorch。
其他资源:
- 推荐阅读: DeepMind 原创雅达利 DQN 论文
- 托马斯·西蒙尼尼的《太空入侵者朱庇特笔记本教程》
- 深度强化学习的偏差-方差:如何用 OpenAI Gym 为雅达利打造一个机器人
3.用 PyBullet 模拟控制任务
PyBullet 人形例子(作者截图)
如果强化学习应用于机器人是你感兴趣的领域，你可能已经见过 OpenAI Gym 的付费 MuJoCo environments。对于一个免费的开源替代方案，我推荐查看一下 PyBullet 。
MuJoCo/PyBullet 是物理引擎，提供类人机器人和其他生物的真实世界般的刚体模拟。它们可用于创建具有连续控制任务(如行走、跑步和游泳)的环境，使其可用于试验政策梯度方法，如 DPG、TRPO 和 PPO。
10 月 19 日更新: MuJuCo 现已免费开源！
4.使用 Unity ML-Agents 创建您自己的强化学习环境(适合初学者)
Unity ML-Agents 推块环境(作者截图)
Unity ML-Agents 是 Unity 游戏引擎的一个相对较新的插件。它允许游戏开发者为游戏训练智能 NPC，并使研究人员能够创建图形和物理丰富的 RL 环境。要探索的项目创意包括:
- 尝试 PPO、SAC、GAIL 和 Self-Play 等算法，这些算法提供了现成的实现
- 在 Unity GUI 中的 18+环境库中训练代理，包括躲避球、足球和经典控制问题。
- 创建您自己的自定义图形和物理丰富的 3D RL 环境
其他资源:
5.用 AWS DeepRacer 比赛自动驾驶汽车(适合初学者)
AWS DeepRacer 联赛流(作者截图)
AWS DeepRacer 是一款 3D 赛车模拟器，旨在帮助开发者使用亚马逊 SageMaker 开始使用 RL。你需要为在 AWS 上培训和评估你的模型付费。作为 AWS DeepRacer league 的一部分，它每月都会举办竞赛，颁发奖品并提供在 re:Invent 比赛的机会。
DeepRacer 的独特之处在于，你可以花 399 美元购买一辆 1/18 比例的赛车，这样你就可以在现实世界中部署你的模型。
其他一些与自动驾驶相关的开源项目:
6.用密涅尔在《我的世界》开采钻石
MineRL 包含超过 6000 万帧记录的《我的世界》人类玩家数据的模仿学习数据集。目标是训练能够在开放世界中导航并克服固有挑战的代理，例如具有大量等级和稀疏回报的任务。
MineRL 提供了有用的入门教程以及一个有用的社区。作为额外的激励措施，作为 NeurIPS 2021 的一部分，MineRL 目前正在举办两项竞赛:
7.加入 AIArena 星际争霸 2 建筑代理的社区
如果你想训练代理人玩高度复杂的主流游戏，你应该去看看 AIArena。他们为一个研究人员、从业者和爱好者的社区运行常规的流和梯，为星际争霸 2 构建脚本和深度学习代理。
除了星际争霸 2，这里还有一些你可能感兴趣的其他主流 RL 框架游戏:
8.用 OpenSpiel 建造一个象棋机器人
照片由 Jani Kaasinen 在 Unsplash 上拍摄
如果你受到了像 StockFish 或 AlphaGo 这样的程序的启发，DeepMind 的 OpenSpiel 值得一看。它包含一系列游戏环境，包括国际象棋、围棋、双陆棋等等。
如果你想尝试树形搜索/规划(例如 MCTS)，以及政策和价值网络，棋盘游戏中的 RL 是一个很好的探索空间。
额外的想法
以下是一些额外的项目想法，也值得一试:
- 用 TensorTrade 预测股票价格
- 用 PettingZoo 训练合作代理
- 用 RLCard 建造一个扑克机器人
- 参加人工智能编程竞赛或 RL 竞赛
结束语
在强化学习中有大量令人兴奋的项目可以探索。这个列表并不全面，但我希望它能给你自己的 RL 项目一些启发！
当今时代的 8 项革命性人工智能技术
探索和分析将会或已经对世界产生重大影响的 8 项人工智能技术
本·欧布罗在 Unsplash 上的照片
人工智能的兴起导致了快速改变世界的技术的产生，这些技术可以影响所有实体的未来，最好是为了人类的更好。
世界的现代一代在技术上是先进的，进步和改进的步伐不断加快，没有减缓的迹象。我们生活的这个时代将被证明是有史以来最具影响力的时代。
人类进步的曲线总是倾向于指数曲线。火道的发现可以追溯到几千年前，车轮的发现，17 世纪和 18 世纪高质量发展的发明，最后是技术进步的现代，大多数发明都是在这个时代做出的。
过去二三十年的发明和发现几乎是过去所有年份产品总和的两倍。随着人类智力的日益提高，以及人工智能和地平线数据科学的兴起，人工智能的现代技术将前所未有地影响世界，并改变整个未来的格局。
那么，是什么让我们花了这么长的时间达到这种智能水平来创造开创性的发明，从而对科幻未来产生深远而有效的影响呢？
人工智能、机器学习和神经网络的概念已经存在了将近一个多世纪。然而，尽管他们最初取得了短暂的成功，但他们从未有过闪光的时候。失败的主要原因是技术进步尚未充分发挥潜力。此外，没有足够的数据可供深度学习模型和神经网络产生重大影响。
直到大约十年前，深度学习的流行才开始爆发。神经网络炒作的重新出现源于 2012 年的一个事件，其中乔治·e·达尔(George E. Dahl)领导的团队利用多任务深度神经网络预测一种药物的生物分子靶点，赢得了“默克分子活动挑战”。在这一事件之后，深度学习和神经网络被持续用于执行与图像分割、对象检测等相关的各种任务。
我强烈推荐通过下面提供的链接查阅下面这篇关于神经网络的有趣而复杂的历史的文章。它对现在导致深度学习和神经网络流行的历史事件提供了详细而简明的指导。
在这篇文章中，我们将讨论八种这样的革命性人工智能技术，这些技术已经或将肯定会影响我们都是其中一部分的领域的前景和观点。这篇文章旨在关注当代现有或即将到来的技术，以及人工智能如何与这些巨大的技术相结合，将如何发展和彻底改变我们的社会。
1.智能手机中的人工智能
亚当·亚当斯在 Unsplash 上的照片
从我们日常生活中经常使用的东西开始，一个非常明显但在现代社会中极具影响力的东西是智能手机。
智能手机在各个方面都是“革命性技术”的象征性代表。这些发明奠定了基础，是未来世界技术需要与之竞争的主要基准。
这些手机可以放在你的手掌中，能够执行多种任务，包括全球定位系统(GPS)定位、消息传递、电话呼叫、跟踪选择性设备、在线交易、激活蓝牙系统、访问社交媒体、网络浏览以及许多其他应用。
但是，到底是什么让这些智能手机比它们最初提供的更好呢？
人工智能与这些设备的集成将它们带到了一个完全不同的水平。这些设备的性能得到增强，从而为日常生活中需要解决的常见任务和问题提供更理想的结果和解决方案。
智能手机中的人工智能技术包括基于面部识别的面部锁定系统，可以防止任何未经授权的用户在未经你允许的情况下访问你的智能手机。只有注册用户的脸被识别和授权访问。它使用计算机视觉、深度学习和人工神经网络的概念来执行复杂的人脸识别锁定系统。
如果你有兴趣使用深度学习和计算机视觉从零开始建立一个类似的人脸识别模型，我会推荐你们所有人查看下面的文章。
智能手机中的其他人工智能活动还包括一些自然语言处理和机器学习创新，如自动更正和自动完成功能。这两种技术都极大地有助于为使用这些设备的用户带来独特性、效率和舒适性。
“自动更正”和“自动完成”的功能基于深度学习主题和概念原则，如长短期记忆(LSMTs)、转换器、注意力的序列到序列模型，以及最重要的自然语言处理的核心方面。
最后，提到智能手机的另一个神话般的功能是集成虚拟人工智能攻击者，如谷歌人工智能和 Siri。我们将在本文的其他部分进一步讨论这个主题。
2.自动驾驶人工智能汽车
Vlad Tchompalov 在 Unsplash 上拍摄的照片
自动驾驶的人工智能汽车或自动驾驶汽车是快速发展的未来趋势。许多公司和科技巨头正在将他们宝贵的资源投入到现代化无人驾驶汽车的开发中。
顾名思义，这些汽车是完全自主的，在没有人类用户或任何额外帮助的情况下协调它们的运动。你可以把这些车放在自动驾驶仪上，并在你躺下来小睡一会儿或放松时设置各自的位置。
这些自动驾驶汽车将在交通中行驶，通过检查站，并覆盖全部距离，以完成预定和期望的目标。为了理解这些自动驾驶汽车如何工作的一些主要方法，他们利用了几个附加组件。
这些组件包括用于 360 度调节的光探测和测距(LIDAR)、多个摄像头、安全轮、高质量的先进系统等等。然而，我们将严格关注这些车辆的人工智能方面。
人工智能在这些先进汽车的开发中发挥了重要作用。自主车辆在训练阶段工作的一个主要概念是使用复杂的神经网络。深度卷积神经网络可以使用大量可训练参数，可以使用大量训练数据集来训练这些自动驾驶的人工智能汽车。
对于额外的培训，甚至图像分割和掩蔽的概念，以及数据处理技术，如特定的图像数据增强方法，都可以用于教授这些自动 AI 汽车。经过多次循环和多次训练后，这些模型将开始以相当好的比率运行，并成比例地提高它们的水平。它们能探测到障碍物，并以相当平稳的速度行驶。
现代自动驾驶汽车发展的一个很好的例子可以归功于特斯拉公司，这家由首席执行官埃隆·马斯克领导的公司旨在为电动汽车提供人工智能技术的安装。这些汽车非常有利于未来防止人类容易犯的多起事故。它们也有助于减少污染。
3.电子游戏中的人工智能
丹尼斯·简斯在 Unsplash 拍摄的照片
游戏是一种现象，在这种现象中，铁杆游戏玩家、休闲玩家和业余爱好者幻想游戏中的细节，探索虚拟世界，并享受玩视频游戏的乐趣。我从小就喜欢游戏。说到游戏，我是个书呆子，因为我是它的超级粉丝。就我个人而言，看到游戏世界的巨大变化让我兴奋不已。
随着 Playstation、Nintendo 和 Xbox 等各种游戏机的出现，游戏正在迅速崛起，并且没有任何放缓的迹象。NVIDIA 最近发布了 RTX 3080 显卡，它具有令人难以置信的性能提升，并为游戏增添了前所未有的情色之美。
哦，等等！谈论图形处理器(GPU)点燃了我对游戏和人工智能这两件我最喜欢的事情的兴趣。随着人工智能的进步，游戏的不断发展是非常重要的。
在游戏世界中开发的一些第一游戏使用特定的硬编码序列来执行特定的序列集合。此外，命中扫描技术被用来确定在一些第一人称射击游戏(FPS)中作为保证命中的射击着陆的效果。
随着人工智能的不断发展，为了使 NPC(不可玩的角色)和其他游戏角色对各种情况做出更真实的反应，不断进行更真实的改变。请注意，术语“现实的”在这个上下文中是一个相对的术语。
沿着记忆的小路走，让我想起了玩电子游戏的深刻。从 1993 年的《毁灭战士》到 2020 年的《永恒毁灭战士》,这款游戏的技术发展可谓突飞猛进。我从玩这个开始:
GIF 来自 GIPHY
到现在玩这个
GIF 来自 GIPHY
这项技术已经从像素化的字符发展到更加图形化的方法。在人工智能领域，强化角色的概念在学习游戏的某个方面起着至关重要的作用。你可以用反复点击和尝试的方法训练你自己的 AI 来玩游戏，并允许网络在此过程中发展批判性思维。
人工智能和强化学习的一个例子是 flappy bird 游戏。为该特征构建的人工智能神经网络失败了若干代。然而，经过数百万代的训练，它获得了更好的理解，并以超过人类的水平执行。
游戏行业发展的其他例子可以归功于象棋引擎中的神经网络，这些神经网络表现强劲，并帮助大师们准备新的创新路线。
4.GPT-3
马克·拉斯姆森在 Unsplash 上拍摄的照片
2020 年最令人期待和开创性的创造之一是由 OpenAI 团队创建的 GPT-3 模型。在 1750 亿个机器学习参数上训练的 GPT-3 模型是当代革命性的人工智能技术。它的特性和计算方面使它目前在自然语言处理领域无与伦比。
生成式预训练 Transformer 3 是一个自回归语言模型，它使用深度学习来产生类似人类的文本。这是由旧金山人工智能研究实验室 OpenAI 创建的 GPT-n 系列中的第三代语言预测模型。(查看参考文献【4】从维基获取更多信息)
OpenAI 开发的 GPT-3 可以被认为是一种语言生成算法，它可以像其他人工智能算法一样生成文本。它可以用于预测各种单词和句子，像聊天机器人一样回答问题，或者从头开始生成独特的文本。GPT-3 模型可以从头开始生成整篇文章，包括新闻、杂志等等。然而，令人惊讶的是，这些生产出来的产品几乎不可能区分出是人工作品还是机器作品。
我强烈推荐看看我以前的一篇关于预测下一个单词的文章。它不像神话般的 GPT-3 架构那样先进，但它应该让你简要了解自然语言过程、深度学习和神经网络的概念如何用于创建壮观的事物。
一些人批评 GPT-3 太好了，以至于它绕过了人类水平的智力，与人类并肩竞争。这种每次计算和产生新结果的能力会导致欺诈活动。然而，这种讨论不是本文的范围，因为我们将只关注积极的方面。OpenAI 团队创建的 GPT-3 模型将成为未来几年技术进步的革命性一步。
5.机器人中的人工智能
Jelleke Vanooteghem 在 Unsplash 上拍摄的照片
人形机器人接管整个宇宙的概念一直是科幻(科幻电影)中人们感兴趣的热门话题。然而，这种观点与现实相去甚远，因为我们距离达到一般人工智能的超级放弃水平还有很长的路要走。
机器人学和机器人有几种定义。但是，我们将把重点放在机器人的一般描述上。根据国际标准组织(ISO)，工业机器人被定义为
一种自动控制、可重新编程的多用途机械手，可在三个或更多轴上编程，可固定在适当位置或移动，用于工业自动化应用。
上述定义只是思考机器人的许多可能方式中的一种。任何能够完成运动、自动完成某项任务并有助于造福社会的机电物体，都是我喜欢称之为“机器人”的另一种说法得益于电影和书籍，机器人和人工智能有着悠久的历史关联。
GIF 来自 Giphy
尽管这些方面中的一些可能被认为是今天不切实际的期望，但客观上今天有许多人工智能和机器人的用例。机器人手臂用人工智能编程，以实现任务的自动化。
提到机器人和人工智能结合在一起(智能机器人)可以执行的一些任务，包括用于组装零件的精确组装应用程序、工业中产品的交叉检查和包装、用于衡量客户满意度的服务机器人以及用于执行各种应用程序的开源机器人。
在不太遥远的未来，我们将见证更逼真的人形机器人与人工智能相结合的发展，以创造一个更具生产力和效率的世界。我对人工智能和机器人的未来充满期待。
6.虚拟助手
在 Unsplash 上由 Waldemar Brandt 拍照
简而言之，虚拟助理是一种设备，可以帮助为人类执行各种任务提供指导和帮助，如播放音乐、打电话、发消息等等。像谷歌人工智能、Siri、Alexa、Cortana 和许多其他来自不同公司的类似虚拟助手这样的虚拟助手越来越受欢迎，这是因为它们的能力和它们为人类提供的整体便利。
这些人工智能虚拟助手有可能自动化任何现实任务。这些虚拟助手的范围在增加，并且目前对这些产品有很高的需求。此外，您还可以使用您的人工智能技能来开发一个完整的家庭自动化系统，使用这些虚拟助理在您的家中编程，可以监控、控制和调节各种操作。
我强烈建议查看我以前的一篇文章，内容是使用自然语言处理、神经网络和深度学习从头开始创建独特和创新的聊天机器人。我使用了一维卷积层的概念来解决这个任务。
你开发的这个模型应该有助于更好地理解聊天机器人是如何工作的，也使你能够更好地了解虚拟助手以及 GPT-3 模型的工作。您可以通过下面提供的链接来查看。
随着科技的快速发展，虚拟助理在现代社会中的作用越来越大。在不久的将来，这些虚拟助理的数量和需求将不断增加。因此，这是一个学习和体验人工智能虚拟辅助技术的好时机。
7.增强现实和人工智能
增强现实对观众来说是一种体验，它有助于创建世界和我们周围环境的交互体验，以产生逼真的交互性。这些视觉效果通常是通过计算机或软件生成的，但是这些生成的图像和模型有助于使自然世界看起来更加精彩。
有许多类型的现实变得日益流行。讨论其中的一些是增强现实、虚拟现实和混合现实的技术。我们已经看到了什么是增强现实。增强现实的一个例子是像口袋妖怪 Go 这样的流行游戏。
虽然增强现实只能通过交互式环境来创建增强效果，但虚拟现实可以让用户沉浸在完整的体验中。在虚拟现实设备的帮助下，你经常会被带入一种完全沉浸式的体验。混合现实是增强现实和虚拟现实的结合。(有关该主题的更多信息，请参考参考文件【6】)
虚拟技术和人工是天作之合。这两个功能结合在一起，可以从虚拟世界中创建动态功能和期望，这曾经被认为是不可能的。为了说明人工智能虚拟现实的一个例子，我想回到游戏的话题。
2020 年(本文发表的前一年)，流行游戏公司 Valve 制作了一款名为 Half-Life Alyx 的游戏，该游戏在各方面都具有开创性。下面的 GIF 是结合了人工智能力量的虚拟现实的简单表示。
GIF 来自 GIPHY
在增强现实和人工智能的帮助下，你可以被带到一个完整的虚拟宇宙，这是如此的逼真，以至于你可以有一个奇妙的体验。人工智能的特点，如敌人的机器人或不可玩的角色(NPC)，只是给虚拟生成的世界增加了更多的物质和内容。
增强现实和人工智能集成在一起时，会有无限的可能性。推测和思考多种独特的排列和组合是令人兴奋的，我们可以用这些技术来创造令人兴奋的产品，这些产品将被证明是未来几年的美丽特征。
8.物联网设备与人工智能相结合
物联网，顾名思义，就是借助互联网控制周围所有交互元素的艺术。最近一段时间，人工智能的受欢迎程度已经超出了比例，因为可以用它们生产大量高质量的产品。
借助 Arduino、Raspberry Pi、Nvidia Jetson Nano 和许多其他嵌入式设备，以及传感器、电机和其他可以通过蓝牙模块或 Wi-Fi(基本上是互联网)控制的物理组件的组合，您可以创建出色的产品。
我们已经确定，物联网是一项卓越的突破性技术，其产品能够实现很高的成功率。然而，随着人工智能融入物联网(有时也称为 AIoT)，这些技术将在世界的发展中创造一场新的革命。
物联网的人工智能技术允许你创造多种产品和技术。其中一些甚至包括前面提到的技术，如自动驾驶汽车(或自动驾驶汽车)、特定任务机器人等等。
物联网与人工智能相结合可以创造许多精彩的发明，这些发明将导致未来的整个景观朝着更好的方向改变。Tensorflow 甚至还有 Tensorflow-lite 等版本支持嵌入式系统。
像谷歌这样的公司正在大力投资制造更小的芯片，并将人工智能的技术安装在这些组件中，这些组件的大小仅为几纳米(芯片可以澄清这种说法)。人工智能和物联网将标志着一场揭示人类未来的新革命。
我强烈建议从下面提供的链接中查看下面的文章，以更深入地了解物联网和人工智能的主题。
结论:
引用一些名人关于人工智能技术未来的名言——
“AI 是新电。它将改变每一个行业，创造巨大的经济价值。” —吴彦祖
“我能想到的最不可怕的未来是，我们至少让人工智能民主化……(而且)当有一个邪恶的独裁者时，那个人就要死了。但是对于人工智能来说，就不会有死亡。它会永远存在。然后你会有一个不朽的独裁者，我们永远无法逃脱。” —埃隆·马斯克
在本文中，我们讨论了八项具有影响力和革命性的人工智能技术，这些技术有能力将世界的未来塑造成一个现代化的趋势领域，以全面提高生活质量。这些人工智能技术随着各个研究领域的进步和不断更新而迅速发展。
让我们快速回顾一下本文中简要提到的这八项技术。第一个是我们日常使用的技术，智能手机。我们了解人工智能在这些智能手机中的影响，以及它如何帮助改善用户体验。然后，我们详细讨论了自动驾驶汽车的人工智能的未来，以及这些自动驾驶汽车将如何在不久的将来成为一部分。
然后，我们开始了解人工智能在游戏行业的影响以及几十年来的演变。然后，我们了解了去年最热门的话题之一，这是由于 GPT 3 号技术的发射，这是一项具有里程碑意义的技术创新。
然后，我们讨论了机器人技术和具有人工智能的虚拟助手，以及它们如何为世界的现代化发展新趋势。我们了解到这些重大趋势带来的无数可能性和光明未来。
我们还探讨了增强或虚拟现实的主题，以及它与人工智能的结合将如何有助于在不同的维度和角度进化世界。最后，我们讨论了物联网和人工智能技术，以开发高质量的产品，并将未来的景观改变为更加现代化的时代。
如果你认为我错过了你认为应该在列表中的任何其他革命性的人工智能技术，并且你希望我在未来的文章中涵盖它，请随时告诉我。此外，如果您对文章中提到的要点有任何其他疑问，请随时在下面评论，我会尽快回复您。
看看我的其他一些文章，你可能会喜欢读！
</5-best-ways-to-earn-income-from-data-science-a9c8fed1eee6> </10-best-tools-and-technologies-for-data-science-e335fb99c2f2> </15-awesome-python-and-data-science-projects-for-2021-and-beyond-64acf7930c20>
谢谢你们坚持到最后。我希望你们喜欢阅读这篇文章。我希望你们都有美好的一天！
参考资料:
你应该知道的 8 个简单有用的 Streamlit 技巧
编写更好的简化应用
web 开发有几种通用的 Python 框架，包括 Flask 和 Django。然而，当涉及到数据科学的世界时，数据科学家或机器学习工程师不是 web 开发人员，他们没有兴趣花几周时间学习使用这些框架来构建 web 应用程序。相反，他们想要一个更容易学习和使用的工具，只要它可以显示数据并收集建模所需的参数。
这就是 Streamlit 发挥作用的地方——一个简单易用的 web 框架，允许我们构建基于数据的交互式 web 应用程序。如果你已经非常了解 Python，那么只需要几个小时，你就可以构建一个有意义的 web 应用。当然，学会使用它需要一些尝试和错误。在这篇文章中，我想分享一些帮助我构建 web 应用程序的技巧。
1.显示源代码以提供上下文
当您向对查看您的代码感兴趣的同行显示数据时，在 web 应用程序中显示您的代码非常有用。为此，您可以使用code小部件，它支持 Python、JavaScript、SQL、Java、Ruby 和许多其他常见语言。
显示代码块
显示直接负责小部件或其相关数据的代码通常很有用。诀窍是使用echo函数，如下所示。
with st.echo():
fruits = ['apple', 'banana']
http_response = (404, 'Page Not Found')
st.radio("Choose Fruit", fruits)
st.text_input("HTTP Responses", http_response)
下图显示了您将在屏幕上看到的内容。本质上， with 语句中的所有内容都将包含在一个代码块中。
使用 echo()
2.使用侧栏收集可配置的参数
如果您的 web 应用程序要根据用户输入显示数据和相关数字，那么在侧边栏中放置相关的小部件是一个好主意。这种分离使得交互性的意图对用户来说很清楚——侧边栏提供参数(即输入),而主屏幕响应用户的输入提供反馈(即输出)。
下图只是给你一个思路。如果你有更多的参数，使用侧边栏可以提高你的应用程序的整洁度。但是需要注意的是，侧边栏的宽度是有限的，所以要避免长文和大 widgets，这样会让信息流有断裂感。此外，如果您有太多超过屏幕高度的参数，您可能会考虑重新组织您的小部件。
使用侧边栏
3.对可选部分使用扩展器
如果您有一些对于大多数用例来说不太重要的参数，您可以将它们折叠成一个扩展器。扩展器可以选择默认扩展或不扩展。
使用扩展器
顺便说一下，你看不到的是我使用了echo()函数来包含代码，这样它就显示在 web 应用程序上了。
4.使用列来组织并行参数
当您拥有属于一个共享概念组的参数时，您可以使用列为这些小部件创建物理上的邻近性，这样用户就知道这些参数是密切相关的。下面是一个简单的例子。
使用列
5.使用无线电作为导航工具
当您的 web 应用程序包含多个具有不同用途的组件时，您可能会考虑使用基于选项卡的应用程序。但是，Streamlit 还不支持选项卡。一种解决方法是使用侧边栏中的radio小部件作为导航工具。请参见下面的使用案例。
导航无线电
6.为重点创造视觉线索
Streamlit 具有方便的功能，可以将某些文本显示为标题和副标题。它们是创建剖面的重要视觉线索。除了这些标题之外，我们还可以使用 markdown 来创建其他用于不同目的的视觉提示。一些常见的包括粗体、斜体和 weblink，如下所示。
降价的视觉提示
上面的代码还向您展示了如何在不同的部分之间添加显式分隔符，这可以改善描述。
7.创建可下载的链接
如果您准备了一些用户想要下载的输出文件，我们可以利用 Streamlit 中的 markdown 功能来完成。
可下载链接
该示例向您展示了如何为数据帧创建下载链接。你也可以对任何文本文件这样做。
8.稍后使用容器添加小部件
有时出于某种原因，您需要操作代码中之前添加的小部件，您不能直接修改之前的小部件，因为 Streamlit 线性地运行脚本。在这种情况下，您应该考虑使用一个容器来包装前面显示的小部件。该容器可以在以后被引用，并允许您添加额外的小部件。下面的截图向您展示了这样的用法。
使用容器
结论
在本文中，我们回顾了您可以在 Streamlit web 应用程序中尝试的 8 个有用功能。当然，Streamlit 仍在快速发展，我们应该期待它会变得越来越好。
你需要知道的 8 个 SQL 日期函数
照片由 Towfiqu barbhuiya 在 Unsplash 上拍摄
SQL 中有如此多不同的日期函数，很难将它们全部记录下来！然而，它们是一些最方便的函数，尤其是在处理时间序列数据时。
在重建一些核心数据模型时，我遇到了一个以前从未听说过的日期函数。我想可能还有其他人没有听说过这个函数，甚至是我将要提到的一些函数。
无论是 SQL 忍者还是初学者，这篇文章都将是在 SQL 代码中使用日期的很好的复习或介绍。
Timestampdiff()
时间戳确实如其名。它找出两个时间戳之间的差异。
这需要不同的参数——一个间隔和两个日期值。
timestampdiff(MONTH, '2021-12-01', '2021-12-31 06:03:15')
间隔可以是Month、Year、Minute、Second。
输入:2日期或日期时间值(日期自动读取为 00:00:00)和间隔
输出:您指定的任意间隔中两个日期之间的时间
这个函数对于查找两个 datetime 列之间过去了多长时间非常有用。
请注意，从第二个日期值中减去第一个日期值，使其为正数。如果我们交换这两个日期，我们会得到一个负值。
Datediff()
这和之前的函数是一样的，除了现在我们发现的是两个日期之间的差异，而不是两个日期时间戳。
这仍然需要不同的参数——一个间隔和两个日期值。
datediff(MONTH, '2021-12-01', '2021-12-31 06:03:15')
间隔可以是Month、Year、Minute和Second。
输入:2日期或日期时间值(日期时间自动读取为 00:00:00)和间隔
输出:您指定的任意间隔中两个日期之间的时间
这个函数的工作方式与另一个几乎相同，但是，这个例子中的时间戳将被读作2021-12-31 00:00:00，而不是时间06:03:15。
月份()
这个函数只是从您输入的日期值中提取月份。
month('2021-12-01')返回十二月的值12。
输入: 1 日期或日期时间值
输出:从 1 到 12 的月份数
我发现自己在验证数据模型中的数据时经常使用这种方法。我用它来比较同一个月的数据，以确保行数或聚合匹配。
年份()
该函数从您输入的日期值中提取年份。
year('2021-12-01 01:12:45')返回该年的值2021。
输入: 1 日期或日期时间值
产量:年份
同样，我经常在模型的数据验证阶段使用它。我将使用它来比较大量的数据，而不仅仅是一个月的数据。
当前日期()
这将为您提供 SQL 代码运行日期的当前日期。例如，我在 2021 年 12 月 4 日写这篇博文。这个函数将返回2021-12-04。
current_date()
输入:无
输出:一个日期值
该函数有助于计算从某个日期列值开始经过的时间。经常发现自己和datediff()配合使用。
日期添加()
此函数允许您向日期列添加值。您几乎可以向日期列添加任何时间单位。Hour、Day、Week、Month、Year恰好是比较流行的几个单位。
date_add('2021-12-01', INTERVAL 1 WEEK)
该代码将为日期增加一周，成为2021-12-08。
输入:日期或日期时间值，数值，时间单位
输出:一个日期或日期时间值
Date_add() 有助于创建日期范围或查找未来的时间值。这是我在 web 会话模型中经常使用的一种方法。
Cast()
这是一个经典函数，我几乎在处理日期、日期时间或时间戳的任何时候都会用到。在使用上面提到的任何函数之前，对 SQL 代码中使用的基本列进行操作是很有帮助的。
Cast('2021-12-01' AS timestampntz)
输入:任意日期类型的列名
输出:指定日期类型的列名
CAST() 函数有助于创建所有时间值列的一致性。我在我的一个模型中遇到了一个问题，我在使用 timstampnt 值和时间戳值时，没有意识到这会影响我的输出。这个函数节省了铸造的时间值，并给我正确的输出！
Datepart()
最后，也是最重要的，我自己刚刚学会的最新的 SQL 日期函数！我在重写的一些代码中发现了这个函数，但不知道它有什么作用。经过一番研究，这是我了解到的情况。
datepart() 函数返回时间值列的指定部分。它类似于month()和year()函数，但是允许您选择提取日期的哪一部分。
datepart(year, '2021-12-01')
这段代码将返回2021作为输出。
输入:时间单位、日期或日期时间值
输出:代表指定时间单位的数值
Datepart()看起来确实比month()或year()运行得快一点，所以当在大量数据上运行查询时，这个函数是首选。
结论
无论你是 SQL 的初学者还是专家，你都知道一个充满有用数据函数的工具箱。把它们放在你的后口袋里，你就可以准备好处理任何棘手的约会问题。
正是对细节的关注使一个人成为真正的 SQL 忍者。当您知道多个不同的功能时，您可以选择最适合您的用例的功能。这为您提供了编写代码和运行速度的灵活性。
查看 如何使用 SQL 交叉连接 、 如何使用 SQL 窗口函数 和 如果你正在寻找提高你的 SQL 编码水平的方法，就可以掌握每一个 SQL 面试问题 的最高技巧。
关于贝叶斯神经网络你应该知道的 8 个术语
先验、后验、贝叶斯定理、负对数似然、KL 散度、替代、变分推理和证据下界的意义
照片由 cyda
目标
在上一篇文章中，我们介绍了贝叶斯神经网络(BNN)。对于那些刚到 BNN 的人，确保你已经检查了下面的链接，以便熟悉标准神经网络(SNN)和 BNN 之间的区别。
今天我们就跳到核心，学习背后的数学公式。从这篇文章中，你会学到不同的 BNN 相关术语…
- 我们如何利用贝叶斯推断的概念来更新模型权重和输出的概率分布。
- 我们将为贝叶斯神经网络使用什么具体的损失函数来优化模型。
- 不同的技术和方法在现实生活场景中处理未知的分配问题。
贝叶斯推理
从上一篇文章中，我们知道贝叶斯神经网络会将模型权重和输出视为变量。我们不是找到一组最优估计，而是拟合它们的概率分布。
但问题是“我们怎么知道他们的分布是什么样的？”要回答这个问题，你必须了解什么是先验、后验和贝叶斯定理。下面，我们将用一个例子来说明。假设有两节课——科学课和艺术课，同学们要么戴眼镜，要么不戴眼镜。现在我们从班上随机挑选一个同学，你能说出那个同学戴眼镜的概率吗？
照片由 cyda
1。先验概率 ( 先验)
先验在考虑任何证据之前表达自己的信念。因此，在没有提供任何进一步信息的情况下，您可能会猜测该同学戴眼镜的概率为 0.5，因为(30+20)/(30+20+15+35)= 50/100 = 0.5。这里，我们称 0.5 为先验概率。
2。后验概率 ( 后验)
Posterior 在考虑一些证据后表达一个人的信念。让我们继续上面的例子。如果现在我告诉你那个同学其实是理科班的呢？你怎么看那个同学现在戴眼镜的概率？有了更多的信息，你可能会改变你的信念，更新概率，对吗？更新后的概率我们称之为后验概率。
3。贝叶斯定理
贝叶斯定理是根据证据将先验概率更新为后验概率的数学公式。
由 cyda 拍摄
a 是我们感兴趣的事件，即“该同学戴眼镜”，而 X 是证据，即“该同学在科学课上”。
照片由 cyda 拍摄
现在你明白后验概率是如何根据证据更新的了。对于贝叶斯神经网络，权重的后验概率计算如下
照片由 cyda
损失函数
现在您已经理解了更新权重和输出的公式，但是我们忽略了一件重要的事情，那就是估计概率分布的评估。在下文中，我们将讨论 BNN 经常使用的两种关键测量方法。
4。负对数可能性
对于回归问题，我们将始终使用均方差(MSE)作为 SNN 的损失函数，因为我们只有一个点估计。然而，我们将在 BNN 做一些不同的事情。有了预测的分布，我们将使用负对数似然作为损失函数。
照片由 cyda
好了，我们一个一个来解释。
似然性是作为预测分布函数的观测数据的联合概率。换句话说，我们想知道数据的分布有多像我们预测的分布。可能性越大，我们预测的分布就越准确。
照片由 cyda 拍摄
对于对数似然，我们有它是因为计算简单。通过利用对数属性(log ab = log a + log b ),我们现在可以使用求和来代替乘法。
最后但同样重要的是，我们添加负号以形成负对数似然，因为在机器学习中，我们总是通过最小化成本函数或损失函数来优化目标函数，而不是最大化它。
5。库尔贝克-莱布勒散度 ( KL 散度)
KL 散度是量化一个分布和另一个分布有多大的差异。假设 p 是真实分布，而 q 是预测分布。实际上，它正好等于两个分布之间的交叉熵减去真实分布的熵 p 。换句话说，它解释了预测分布 q 还可以改进到什么程度。
照片由 cyda
对于那些不知道熵和交叉熵是什么的人来说，简单来说，熵是代表真实分布 p 的“成本”的最低边界，而交叉熵是使用预测分布 q 来代表真实分布 p 的“成本”。由此，KL 散度将代表预测分布 q 的“成本”可以进一步降低多少。
所以回到今天的焦点， p 将指模型权重和输出的真实分布，而 q 将是我们预测的分布。我们将使用 KL 散度来计算两个分布之间的差异，以便更新我们预测的分布。
问题与解决方案
不幸的是，边际概率 P(D) 通常很难处理，因为很难找到下面积分的封闭形式。源于此，对于一个复杂的系统来说，后验的P(w| D)也是棘手的。
cyda 拍摄的照片
为了解决这个问题，统计学家们发展了一种叫做 变分推断 的方法，通过最小化 替代 模型的 证据下界 来近似真实的后验分布。
不要担心加粗的条款。我会一一解释。
6。代理人
代理模型是一个简单的模型，用来代替我们感兴趣的复杂模型。它很容易使用，并且和复杂模型一样好。一般来说，代理模型会在统计分布家族中，所以我们有它的解析解。
照片由 cyda
7。变分推理(六
变分推断就是用一个变分分布 q* 来代替真实的后验分布p(w| D)的概念。但是代理模型那么多，怎么才能保证 q* 足够好的表示p(w| D)？答案很简单，我们可以用刚刚学过的 KL 散度。
在代理模型 Q 中，我们试图找到最优的一个
照片由 cyda
8。证据下界
然而，同样的问题仍然存在，因为我们没有后验概率分布。我们能做的是把 KL 散度改写成
照片由 cyda 拍摄
通过考虑
照片由 cyda
我们可以总结出下面的公式。
照片由 cyda
已知 KL 散度是非负数，证据是 0 和 1 之间的概率，因此对数证据必须是非正数，我们可以容易地推导出 L(w) 是证据的下限。这就是我们称之为“证据下界”的原因。换句话说，我们现在可以通过优化找到最优的一个 q*
照片由 cyda
结论
如果你已经看完了以上所有内容，恭喜你！希望你现在已经对贝叶斯神经网络背后的数学概念有了最基本的理解。在接下来的文章中，我将更多地关注关于如何使用张量流概率构建 BNN 模型的编码观点。敬请期待！=)
关于熊猫团购要知道的八件事
Groupby 是如此强大，这对于初学者来说听起来可能令人畏缩，但您不必了解它的所有特性
没有必要证明熊猫图书馆在数据科学领域的重要性。如果使用 Python，这个库是任何数据处理作业的必备工具。熊猫库的一个通用功能是基于groupby函数，它创建了一个GroupBy对象，支持许多可能的操作。
然而，groupby相关的功能是如此强大，以至于我们中的许多人很难记住它的所有功能。此外，通用性的另一个显著副作用是，初学者可能会发现自己迷失在如何使用groupby功能中。在本文中，我想回顾一下我们可以对GroupBy对象执行的 8 个最常见的操作。
1.创建频率表
让我们首先检索我们要使用的数据集(著名的 iris 数据集)，如下所示。
Iris 数据集
当我们拥有包含分类变量的数据记录时，我们通常希望知道按组划分的记录数。在这种情况下，我们可以使用GroupBy的size()功能创建频率表。如你所见，我们对这三个物种都有 50 个记录。
频率表
需要注意的一点是，我们创建了GroupBy对象(即iris_gb，因为接下来我们将多次使用它。
2.计算通用描述性统计信息(例如，平均值、最小值、最大值)
要按组计算平均值，我们只需使用mean()函数。
计算方式
默认情况下，mean()函数将对所有数值列执行计算。如果需要某些列的平均值，我们可以指定该值，如下所示。
列的平均值
以类似的方式，我们可以使用min()和max()函数计算GroupBy对象中各组的最小值和最大值，就像mean()函数一样。我们还可以计算中位数和标准差。
**# Calculate the min**
iris_gb.min()
**# Calculate the max**
iris_gb.max()
**# Calculate the median**
iris_gb.median()
**# Calculate the SD**
iris_gb.std()
3.寻找最大值(或最小值)的索引
当你想找出每个组的最大记录的索引，而不是定位最大记录并找到它的索引时，有一个方便的函数直接为我们做了这项工作。见下文。
最大记录索引
这一功能可能很有用。例如，假设我们想要检索最大萼片长度的记录，我们可以执行以下操作:
组合 idxmax 和 loc
4.Groupby 后重置索引
有时，我们希望在groupby处理之后进行额外的操作。更具体地说，我们希望重置分组索引，使它们成为规则的行和列。第一个选项是在创建的DataFrame对象上使用reset_index()函数。
重置索引
通过在groupby函数中设置as_index参数，第二个选项更加友好。
重置 groupby 函数中的索引
5.多个操作的简单聚合
从技术上来说，我们可以如上图分别执行多个操作。然而，可以通过利用GroupBy对象的agg()函数来执行这些操作。考虑下面这个微不足道的例子。
聚合
- 为了清楚起见，我们只计算两列的结果:
sepal_length和petal_length。 - 在
agg函数中，我们指定想要应用的函数的名称。在这种情况下，我们要求计算两列的最小值和平均值。
6.特定于列的聚合
当我们想要聚合一些计算时，我们并不总是需要对所有列进行相同的计算。在这种情况下，我们可以为不同的列请求不同的计算。请考虑以下情况:
按列的不同聚合
在上面的示例中，我们看到聚合计算了sepal_length的最小值和最大值以及petal_length的平均值和标准差。语法基本上是传递一个字典，其中列是键，计算函数是值。
7.命名聚合
您可能已经注意到，由于涉及到多级索引，输出文件不是太用户友好。与此相关，计算字段没有非常简单的名称。为了解决这个问题，我们可以考虑命名聚合特性，如下所示。
命名聚合
上面的代码利用了 pandas 中实现的NamedAgg。如您所见，四个计算列具有正确的名称。值得注意的是，NamedAgg是一种命名元组，因此我们可以直接传递元组作为快捷方式。等效的代码如下。
iris_gb.agg(
sepal_min=("sepal_length", "min"),
sepal_max=("sepal_length", "max"),
petal_mean=("petal_length", "mean"),
petal_std=("petal_length", "std")
)
8.使用自定义函数
到目前为止，我们在计算中应用的函数是通过名称传递的(例如，“min”、“mean”)。然而，我们可以直接传递一个函数对象。请考虑以下情况。
功能对象
值得注意的是，函数对象可以和函数名一起使用。下面的代码也是有效的调用。
iris_gb.agg(["min", pd.Series.mean])
此外，您可以指定自定义函数。下面的代码片段向您展示了一个简单的例子。
自定义功能
由于 lambda 函数的核心也是函数，我们可以对GroupBy对象使用 lambda 函数，如下所示。代码相当于上面的代码片段。
**# Use a lambda function**
iris_gb.agg(lambda x: x.mean())
结论
在本文中，我们回顾了在 pandas 中使用 groupby 函数对GroupBy对象进行的八个最常见的操作。当然，它并不是GroupBy对象可用特性的详尽列表。相反，它们只是一些与大多数日常数据处理需求相关的重要问题。
掌握熊猫价值排序需要知道的 8 件事
用熊猫有效地排序值
由 Markus Spiske 在 Unsplash 上拍摄的照片
当我们处理数据时，排序是直观检查数据质量的重要预处理步骤。对于 pandas，虽然有时我们可能会使用一个相关的方法— sort_index，但大多数时候我们使用sort_values方法对数据进行排序。在这篇文章中，我想分享 8 件对你完成这个预处理步骤至关重要的事情——重点是sort_values方法。
事不宜迟，让我们开始吧。
1.按单列排序
在本文中，我们将使用 flights 数据集，它记录了从 1949 年到 1960 年的每月乘客人数。出于本教程的目的，我们将选择一个随机子集，如下所示。
用于排序的数据集
当我们希望按单个列对数据进行排序时，我们直接将列名指定为函数调用的第一个参数。顺便说一下，你可能会看到我经常使用head，只是为了在不浪费空间的情况下向你展示最高值。
>>> df.sort_values("year").head()
year month passengers
0 1949 July 148
13 1951 February 150
8 1951 April 163
19 1951 December 166
5 1952 May 183
2.就地排序值
在前面的排序中，您可能已经注意到了一件事，那就是sort_values方法将创建一个新的DataFrame对象，如下所示。
>>> df.sort_values("year") is df
False
为了避免创建新的数据帧，您可以通过设置inplace参数请求就地进行排序。当你这样做时，注意调用sort_values将返回None。
>>> df.sort_values("year", inplace=True)
>>> df.head()
year month passengers
0 1949 July 148
13 1951 February 150
8 1951 April 163
19 1951 December 166
5 1952 May 183
3.排序后重置索引
在前面的排序中，您可能注意到索引伴随着每一个排序的行，当我希望排序的数据帧有一个有序的索引时，这有时让我困惑。在这种情况下，您可以在排序后重置索引，或者简单地利用ignore_index参数，如下所示。
>>> df.sort_values("year", ignore_index=True).head()
year month passengers
0 1949 July 148
1 1951 February 150
2 1951 April 163
3 1951 December 166
4 1952 May 183
4.按多列排序
我们并不总是需要一列来排序。在许多情况下，我们需要按多列对数据框进行排序。使用 sort_values 也很简单，因为by不仅接受单个列，还接受没有任何特殊语法的列列表。
>>> df.sort_values(["year", "passengers"]).head()
year month passengers
0 1949 July 148
13 1951 February 150
8 1951 April 163
19 1951 December 166
17 1952 January 171
5.按降序排序
正如我们到目前为止所看到的，每个排序都是使用升序来完成的，这是默认的行为。但是，我们通常希望数据按降序排序。我们可以利用ascending参数。
>>> df.sort_values("year", ascending=False).head()
year month passengers
18 1960 June 535
6 1958 April 348
4 1958 October 359
1 1957 June 422
7 1957 March 356
按多列排序，对这些列有不同的升序要求，怎么办？在这种情况下，我们可以传递一个布尔值列表，每个值对应一列。
>>> df.sort_values(["year", "passengers"], ascending=[False, True]).head()
year month passengers
18 1960 June 535
6 1958 April 348
4 1958 October 359
7 1957 March 356
1 1957 June 422
6.按自定义函数排序
如果我们想用当前数据集按年份和月份排序，该怎么办？不用想太多就试试吧。
>>> df.sort_values(["year", "month"]).head()
year month passengers
0 1949 July 148
8 1951 April 163
19 1951 December 166
13 1951 February 150
9 1952 August 242
显然，排序后的数据不是我们所期望的——月份没有按照预期的顺序排列。为了实现这一点，我们可以利用sort_method获取一个key参数，我们可以向其传递一个自定义函数进行排序，就像 Python 的内置sorted函数一样。一个可能的解决方案如下所示。
>>> def _month_sorting(x):
... if x.name == "year":
... return x
... months = ["January", "February", "March", "April",
... "May", "June", "July", "August",
... "Septempber", "October", "November", "December"]
... return x.map(dict(zip(months, range(0, len(months)))))
...
>>> df.sort_values(["year", "month"], key=_month_sorting).head()
year month passengers
0 1949 July 148
13 1951 February 150
8 1951 April 163
19 1951 December 166
17 1952 January 171
key接受一个可调用函数，我们在这里使用一个自定义函数。而且这个参数只有熊猫 1.1.0+才有。- 与
sorted()中使用的key参数不同，key函数适用于sort_values方法中的每个排序列。因为我们只想自定义“月”列的排序，所以当列为“年”时，我们希望使用“年”列的原始值。
7.转换为分类后，按字典顺序对无序列进行排序
上面使用key参数的排序可能会让一些人感到困惑。有没有更干净的方法？Pandas 可以说是用于数据处理的最通用的库，并且您可以期待有一些简洁的东西来解决这个相对常见的问题——将这些字典上无序的列转换成分类数据。
按类别排序
- 我们通过指定月份的顺序来定义一个
CategoricalDtype。 - 我们将 month 列转换为新定义的类别。
- 当我们对月份进行排序时，它将使用类别数据定义中月份的顺序。
8.不要忘了 NANs
请务必记住，您的数据集可以始终包含 nan。除非你已经检查过你的数据质量并且知道没有 NANs，否则你应该注意这一点。默认情况下，当我们对值进行排序时，这些 nan 被放在所有其他有效值的后面。如果我们想改变这个默认行为，我们设置na_position参数。
用 NANs 排序
- 我们首先将一个 NAN 注入到
DataFrame对象中。 - 当我们对
na_position不做任何事情时，NAN 值被放在排序组的末尾。 - 当我们将
“first”设置为na_position时，NAN 值出现在顶部。
结论
在本文中，我们回顾了关于熊猫排序值的 8 件事/条件，这应该涵盖了大多数用例。如果你觉得我错过了什么重要的东西，请随时留下评论！
Python 中面向对象编程的 8 个技巧
按照以下步骤让您的 Python 类防弹
由朱利安·迈尔斯在 Unsplash 拍摄的照片。对象没有设计好，已经崩溃。
面向对象编程(OOP)是一种流行的编码范式，因为它确保代码的可重用性并防止冗余。它的吸引力使它在软件工程之外的领域，如数据科学和机器学习工程中很受欢迎。然而，设计一个可以正常工作的对象和编写高质量的代码来充分享受 OOP 方法的好处是有很大区别的。让我们来看看通向防弹 Python 类的八个步骤:
- 在构造函数中设置属性。
- 区分类级和实例级的数据和方法。
- 确定什么是相等的。
- 提供字符串表示。
- 知道什么是静态。
- 决定什么是内部的和私有的。
- 设置对属性的访问。
- 使用文档字符串。
面向对象编程
OOP 基于这样一种思想，即代码和代码使用的数据应该保存在一个地方。因此有了对象的概念，它将数据和代码封装在一起。对象由状态和行为组成。对象的状态保存在其包含的数据中，也称为属性，而行为由方法控制。
对象=状态(属性)+行为(方法)
在 Python 中，对象由其蓝图定义，称为类。“类”的属性表示为 Python 变量，其方法由 Python 函数实现。考虑下面这个代表银行账户的玩具示例类。
它有四个方法，允许我们设置帐户所有者或存款，等等。一旦我们设置了所有者，就创建了owner属性。从我们可以使用它的意义上来说，这个类可能被认为是全功能的。我可以为自己创建一个没有现金的账户，并进行一些交易:
Michal 700
然而，这段代码写得很糟糕，因为它违反了防弹类的所有八个步骤。因此，它可能会以您意想不到的方式失败！让我们一个接一个地看看这八个步骤中的每一个。
#1:在构造函数中设置属性
在我们的 BankAccount 类中，有专门的方法来设置属性:为了给我自己建立一个帐户，我首先创建了一个空帐户，然后我使用set_owner()方法将我的名字分配给owner属性。这并不理想，原因有二。首先，一些属性可能不存在。创建一个没有余额的账户是可能的。那我们怎么存钱呢？第二，在各个地方设置属性。如果这个类中有更多的代码，任何人都很难了解它有什么样的属性。
在构造函数中设置属性，以确保它们存在并且可以在一个地方容易地被发现。
这就是为什么认为在一个地方定义所有属性是最佳实践，设置它们的默认值以便它们总是存在。Python 提供了一种方便的方法:T2 构造函数。当添加到类中时，一旦创建了对象的实例，此方法将自动执行。构造函数也是对属性值进行各种检查的好地方，例如，防止创建一个负余额的新帐户。现在，让我们再添加两个稍后会有用的属性:帐号和创建日期。
现在，我们必须在设置帐户时设置所有者和帐号。不这样做将导致错误。如果我们不设置余额，它将默认为零。
Michal 123 0
#2:区分类级和实例级的数据和方法
有些属性和方法通常是类固有的，而有些则是该类的实例特有的。区分这两者是至关重要的，以确保个人的银行账户不会改变银行账户的一般运作方式。
实例级数据通常不应该干扰类的工作方式。将它与类级别的数据分开。
先说属性。像owner、account_number、created_at或balance这样的变量是实例级数据，因为它们对于每个帐户可能是不同的。然而-10，000 的余额阈值是类级别的，我们用它来比较新创建的帐户的余额:有一条规则，不能用更低的余额来设置帐户。我们不应该硬编码它，而是应该在类定义本身中将其赋给一个属性，并在以后通过self.进行访问。
至于方法，deposit()和withdraw()对于类的每个实例都以相同的方式工作，即对于每个单独的帐户，然而它们被认为是实例级方法。这是因为它们需要一个实例才能使用。在存钱之前，我们需要先建立一个账户。这反映在每种方法的self论证中。self表示实例，即我们存款或取款的特定账户。
类级方法对于从外部源(如 csv 文件)创建类对象非常有用。
可以在 Python 中创建类方法，使用cls而不是self，也就是说:它们不需要实例存在。他们流行的用例是实际上从外部来源创建一个实例。我们可能希望有一个方法，从一个名为testfile.csv的 CSV 文件创建一个 BankAccount 实例，该文件以逗号分隔的格式包含所有者和帐号:Michal,123。为此，我们可以添加一个from_csv()方法。我们用@classmethod装饰器装饰它，并使用类引用cls作为第一个参数。我们可以在 return 语句中使用它，使方法基于 CSV 文件的内容返回类实例。这是我们更新的 BankAccount 类:
下面是我们如何使用from_csv方法:
Michal 123 0
#3:确定 was 是否相等
我们现在有一个像样的质量代码！是时候实际使用了。如果我们创建两个相同的帐户，并使用等式运算符对它们进行比较，您认为会发生什么情况？
False
这两个帐户拥有相同的所有者、帐号和创建日期，但是用等号运算符比较它们会产生一个False。为什么会这样？
当比较一个对象的两个实例时，Python 会查看它们占用的内存块。由于这两个是独立创建的，它们位于我的计算机内存的不同部分。
当比较一个对象的两个实例时，Python 会查看它们占用的内存块。为了获得有意义的比较，明确定义等式。
然而，在我们的例子中，我们可能希望具有相同号码和所有者的两个帐户被认为是平等的。这可以使用特殊的__eq__()功能来实现。当在类中定义时，每当使用==操作符比较类实例时，就会自动使用它。这个等式函数接受代表两个对象的两个参数，通常称为self和other，当对象被认为相等时应该返回True，否则返回False。如果我们希望两个帐户具有相同的帐号，那么在我们的类中添加以下代码就足够了:
同样，用户可以定义一个对象何时应该被认为大于另一个(__gt__())，小于或等于另一个(__le__())，等等。
#4:提供字符串表示
一旦我们定义了一个银行帐户，我们可能想要打印它来看看它是什么样子。
<__main__.BankAccount object at 0x7f9ec0716a10>
不是很有意义，是吗？这个打印输出显示了对象的类型，即BankAccount，以及一个十六进制的数字，它指向存储它的内存块。相反，我们可能希望print()返回更多信息和用户友好的东西。例如，打印熊猫数据帧，以人类可读的格式向我们展示数据。熊猫们是怎么做到的？
为对象定义字符串和可再现的表示使其在打印时可读并且易于再现，例如用于调试。
通过为我们的对象提供字符串表示，可以覆盖正在打印的内容。这是通过定义特殊的__str__()函数来完成的。它唯一的工作就是输出我们想要打印的字符串。另一个相关的概念是可再现表示，或 repr。定义特殊的__repr__()函数来提供可用于重新创建对象的精确字符串是一个最佳实践，这使得理解对象是如何创建的变得容易。让我们将所有这些都添加到代码中。注意，我们还在类中添加了一个助手函数来处理解析日期。我们稍后会详细讨论这个问题。
这是它给我们的启示:
Bank Account:
Account Owner: Michal
Account Number: 123
Creation Date: 2021-05-24
Current Balance: 0"BankAccount(owner='Michal', account_number=123, balance=0)"
首先，我们得到一个用户友好的银行账户字符串表示。第二，通过调用 repr，我们得到一个字符串，可以对该字符串求值，以在当前状态下重新创建对象。
#5:知道什么是静态
在上一节中，我们添加了一个处理简单日期格式的to_dash_date()函数。它不访问该类的任何数据或方法。实际上，我们可以把它放在类的外部，但是由于它是由__str__()函数用来实现人类可读的字符串表示的实用程序，所以把它放在类内部是有意义的。
将函数标记为静态可以节省内存并提高代码可读性。
这样的函数称为静态函数。Python 允许使用@staticmethod装饰器显式地标记静态函数:
这样做有几个好处。首先，它消除了使用self参数的需要，因为该方法不需要访问类实例。其次，它减少了内存使用(在这种情况下，Python 不需要创建绑定方法)。最后，将方法标记为 static 可以提高代码的可读性，因为它直接告诉人们这个方法是一段独立的代码，与类实例的状态无关。
#6:决定什么是内部的和私有的
任何类中的一些方法和属性都旨在由代码的用户显式使用，例如我们的 BankAccount 类中的withdraw()和deposit()方法。然而，有些却不是。to_dash_date()方法是一个辅助工具，由底层的类调用，但不打算手动调用。这样的方法和属性被称为内部，最佳实践是以下划线开始它们的名称，这样我们就有了_to_dash_date()、self._owner等等。这种命名约定本身并不做任何事情，但是它允许人们在查看您的代码时立即识别出哪些方法不是公共 API 的一部分，因此在代码的未来版本中可能会发生意想不到的变化。
一个相关的主题是私有方法和属性。您可能想要对外界隐藏一些方法或属性，例如，确保它们不会被覆盖。在 Python 中，没有使它们完全隐藏的机制，但是我们可以通过用前导双下划线命名它们来将它们标记为私有的。例如，我们可能希望最小余额阈值是私有的，因此我们这样设置它:
前导下划线用于命名内部方法和属性，而双前导下划线标记私有方法和属性。
现在，即使像往常一样可以在类中访问它，调用my_account.__MIN_BALANCE也会抛出一个异常。这向用户表明该属性是私有的，不能被篡改。然而，由于一个叫做名称篡改的技巧，访问它是可能的。Python 自动将私有内容从object.__privatestuff转换为object._classname__privatestuff，因此我们可以以my_account._BankAccount__MIN_BALANCE的形式访问私有属性。然而，应该避免这种做法。
#7:设置对属性的访问
考虑这段代码:
Bank Account:
Account Owner: Michal
Account Number: 123
Creation Date: 1900-01-01
Current Balance: -999999
如您所见，更改现有帐户的创建日期以及将余额设置为一个大的负数是非常容易的。回想一下，创建日期是在对象创建时自动设置的，由于在 __init__()方法中的输入验证，我们不能设置一个负余额的帐户。我们能做些什么呢？理想情况下，创建日期应该是一个只读属性，余额应该在每次更新时进行一些验证。这可以在 Python 中使用属性和设置器来实现。
使用属性和设置器将属性设置为只读，并验证它们的更新。
比方说，要使balance属性成为只读的，只需要向类中添加一个函数，就像用@property装饰器装饰的属性一样，并返回属性值。
现在，一旦在创建时设置，属性的值就不能更改。
0--------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-179-97fdccecdd35> in <module>
**2**
**3** print(my_account.balance)
----> 4 my_account.balance = 100
AttributeError: can't set attribute
酷！这对于帐号或创建日期是可行的，但是为了平衡，我们实际上希望是可更新的——但是不能有太大的负值。为了实现这一点，我们需要在属性修饰方法的基础上再做一件事。我们还需要类中的另一个函数，也叫做balance，并用@{attribute_name}.setter修饰器修饰，在本例中是@balance.setter。该函数应该以一个新的余额作为参数，并更新对象中的属性值。当它更新时，我们可以添加任何我们想要的验证。例如，为了确保余额不会低于我们的最小阈值，我们可以执行以下操作。
现在，每次设置balance属性时，setter 方法都会被调用，因此我们的验证会运行。因此，不允许余额低于-10.000。
1000
-1000
-3000
-5000
-7000
-9000--------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-182-37ef4b15da69> in <module>
**3** for i in range(10):
**4** print(my_account.balance)
----> 5 my_account.balance -= 2000
<ipython-input-181-8849326b10e3> in balance(self, new_balance)
**19** def balance(self, new_balance):
**20** if new_balance < self.__MIN_BALANCE:
---> 21 raise ValueError("Balance to small!")
**22** else:
**23** self._balance = new_balance
ValueError: Balance to small!
#8:使用文档字符串
最后但同样重要的是，文档！与 readmes 形式的外部文档不同，docstrings 不会很快过时。首先，因为当我们更新下面的代码时，更容易记住更新它们，其次，因为大多数 ide 会提醒我们过时的文档字符串。当一个人第一次使用代码时，它们确实有助于他理解代码。那么，docstrings 类中应该包含什么，以及如何编写它们呢？
PEP8 是广泛使用的编写 Python 代码的风格指南，它陈述了以下内容。
为所有公共模块、函数、类和方法编写 docstrings。对于非公共方法，Docstrings 不是必需的，但是应该有一个注释来描述该方法的作用。该注释应出现在“def”行之后。
因此，我们应该包括公共的deposit()、withdraw()和from_csv()方法。除了所有的属性、设置器和特殊方法，唯一的非公共方法是_to_dash_date()，所以它会得到一个注释。至于属性，我们不一定要包括私有的 __MIN_BALANCE，但是它看起来对文档很有用。向下滚动我们的全新类 docstring。
最后，这是经过所有改进后的银行帐户类。
总而言之，下面是再次实现防弹 Python 类的步骤:
- 在构造函数中设置属性。这样，它们将一直存在，并在一个地方定义。
- 区分类级和实例级的数据和方法。实例级数据一般不应该干扰类的工作方式，应该与类级数据分开保存。例如，可以使用类级方法从外部源(如 CSV 文件)创建类实例。
- 确定什么是相等。当比较一个对象的两个实例时，Python 会查看它们占用的内存块。要获得有意义的比较，请明确定义等式。
- 提供字符串表示。为对象定义字符串和可再现的表示，使其在打印时可读，并易于再现，例如用于调试。
- 知道什么是静。显式地将函数标记为 static 可以节省内存并提高代码可读性。
- 决定什么是内部，什么是私有。前导下划线用于命名内部方法和属性，而双前导下划线标记私有方法和属性。这种做法告诉您的代码用户哪些部分不是公共 API 的一部分，不应该被依赖。
- 设置访问属性。使用属性和设置器将属性设为只读，并验证它们的更新。
- 使用文档字符串。第一次使用代码时，这确实有助于理解代码。
感谢阅读！
如果你喜欢这篇文章，为什么不在我的新文章上 订阅电子邮件更新 ？而通过 成为媒介会员 ，就可以支持我的写作，获得其他作者和我自己的所有故事的无限访问权。
需要咨询？你可以问我任何事情，也可以在这里 为我预约 1:1 。
也可以试试 我的其他文章 中的一篇。不能选择？从这些中选择一个:
[## 贝叶斯数据分析最温和的介绍
towardsdatascience.com](/the-gentlest-of-introductions-to-bayesian-data-analysis-74df448da25)
大大提高 VSCode 工作效率的 8 个技巧
我给第一次使用 VSCode 或从另一个 IDE 转换过来的人的 8 个技巧。
无论您是工程师还是分析师，熟悉 IDE 都是至关重要的一部分。对于不太熟悉 Vim 或 VSCode 的人来说，看着一个高级开发人员在 Vim 或 vs code 中跳来跳去可能会感到害怕。然而，我向你保证，这里没有魔法。当你陷入困境时，这都是练习和搜索答案。
我在这篇文章中分享的大部分技巧将会大大提高你的工作效率。一旦你学会了这些，你将很难想象没有它们的生活。
1.所有快捷方式的大师
如果从这篇文章中你学到了一个捷径，那就是: ⌘ + Shift + P (在 Windows 上你可以用所有的⌘键代替 Ctrl，用 option 代替 alt)。此快捷方式在 VSCode 中打开控件面板，您可以在其中搜索命令、操作和其他快捷方式。
命令面板—作者的 GIF
尝试搜索Copy path of active file或Copy relative path of active file并按回车键。没有更多的摸索尝试输入准确的文件路径到您的终端。最重要的是，您不必记住这些命令的实际快捷方式。你只需要记住它们做什么，并在命令面板中搜索它们。
命令调板还会记住您最近打开的一些项目，以便您可以快速浏览它们。
2.在您的存储库中导航文件
打开命令面板后，您可以删除>字符或使用 ⌘ + P 命令在 repo 中搜索文件。如果您的项目结构错综复杂，并且需要花费时间来浏览，这将非常有用。使用这个命令，您只需记住文件名。
作者在 repo-GIF 中导航所有文件
搜索引擎挺好的，文件名长的话只需要输入名字的首字母就可以了。例如，你只需要在搜索栏中输入ssp来搜索一个名为stg_stripe__payments.sql的文件。
当您在 VSCode 窗口中打开 repo 时，您可以通过单击它们来快速预览文件。双击一个文件将打开它永久居中或在左手边。双击该文件将在右侧打开它。当您想并排比较两个文件的内容时，这非常有用。
3.多光标编辑
当使用代码文件时，这部分将会大大提高你的效率。多光标编辑是同时拥有多个光标并从所有这些光标进行编辑的能力，而不是一次编辑一个光标。让我们使用一个 SQL 查询，看看多游标的一些用例。
这里可能会有一些新的东西需要学习，但是如果你掌握了所有的东西，你就可以四处走动，很快地把事情做完。我发现自己经常将 Word 等其他程序的代码片段复制到 VSCode 中来操作它们。
重命名所有实例
一个常见的做法是选择所有事件，然后一次全部更改。在下面的例子中，我们的表的名称从orders更改为order。为此，您只需选择单词orders的一个实例，并使用 ⌘ + shift + L 。该快捷方式将在单词orders处创建多个光标，以便您对其进行编辑。
这很像搜索，但更具灵活性。
如果我们把这个查询改成不同的方言，并且所有的列名都应该用双引号括起来。我们可以选择字符.的所有实例，并使用 Shift + → 来选择下一个单词。选择了所有的列名后，我们可以输入"将它们都用引号括起来。
引用所有列名—作者的 GIF
下一个例子是当我们有一个长而复杂的查询，并且只想改变 select 语句中的事件时。您可以使用⌘+ F 启用搜索模式，然后选择您想要操作的区域。接下来，按下 ⌘+选项+ L 仅在选定区域搜索。您现在可以使用 ⌘ + shift + L 并将错别字订单更改为订单。注意，from 语句中的单词order不受影响。
将多行转换成 Python 列表
现在，让我们尝试提取这个查询中的所有列名，并将其转换成一个 Python 列表。对于前四列，我们可以使用新的快捷方式来选择它们。首先，选择第一列中.字符后的空格。然后按住 shift + option 选择最后一列相同的空格。你可以看到，有了这个，我们已经创建了多行光标。要添加最后一列，您可以按住选项并选择它。最后，使用选项 + →选择所有列。
选择所有列—作者的 GIF
使用复制的列，您可以将它们粘贴到下面，使用 shift + option 选择所有行，引用它们，添加逗号，删除新行，并将所有内容放在方括号中。
将复制的列转换为 Python 列表—作者制作的 GIF
4.重新排序行
您可以使用选项+光标上下移动任意行，而不是复制粘贴来改变行的顺序。您可以同时选择多条线，也可以使用此功能。
使用光标移动线条-作者的 GIF
您也可以根据行的长度来缩短行，方法是选择行，打开命令选项板，然后选择升序或降序对行进行排序。
使用命令调板对行进行排序—作者提供的 GIF
5.代码折叠
对于复杂的代码，有时很难知道发生了什么。如果代码格式良好，您可以使用Fold All命令面板的命令折叠所有代码。这让我们对正在发生的事情有了一个高层次的概述，我们可以深入到我们感兴趣的特定领域。
折叠所有代码—图片由作者提供
您也可以分别使用以下命令来折叠和展开选择: ⌘ + option + [ ， ⌘ + option + ] 。
6.格式化
编写代码时，拥有格式清晰的代码对于保持可读性至关重要。VSCode 因其丰富的扩展库而广受欢迎，您可以在那里找到 linter 来格式化大多数编程语言。
代码格式—作者提供的 GIF
要自动格式化文件，您可以使用命令 option + shift + F 。如果您试图格式化的文件扩展名的 linter 没有安装，VSCode 将提示您这样做。在处理 Python、SQL 或 Terraform 文件时，我经常使用这个快捷方式。
7.在回购中查找实例
有时你有一个价值，你必须改变你的回购。它可以是函数名或变量。手动查找和更改它们可能会很痛苦。您可以使用 ⌘ + shift + F 在您的 repo 中找到一个单词或短语的所有实例，并用其他内容替换它们。
8.切换终端
终端是任何软件开发工作流程的重要组成部分。您可以使用快捷方式: **control + ** 打开与您的编码环境相关的终端。你可以在终端中使用命令面板来Run current file`。
如果你正在用 Python 开发，我真的很喜欢选择一段代码并在本地的 Jupyter 环境中执行它。选择您想要执行的文本，并使用shift+enter—非常类似于 Jupyter 笔记本中的单元格。
(奖金)使用通用剪贴板管理器
我现在不能没有剪贴板管理器。剪贴板管理器能够保存你复制的任何东西，并保存一段时间(1 到 3 个月取决于工具)。你也可以在那里搜索物品。例如，如果我想记住我最近使用brew安装的一个包，我只需要在我的剪贴板管理器中搜索brew。
剪贴板管理器的魔力——作者 GIF
有许多剪贴板管理器。但是如果你用 Mac，我推荐你去看看 Alfred(付费)和 Raycast(免费)。它们都非常棒，还包含其他功能。
我希望你能从这篇文章中学到一些东西。直到下次😁
8 种取样技术
了解采样方法(视觉和代码)
图片来自作者
抽样是从较大的总体中选择一个子集(预定数量的观察值)的过程。这是一种很常见的技术，我们进行实验并得出关于群体的结论，而不需要研究整个群体。在这篇博客中，我们将介绍两种采样方法:
- 概率抽样—这里我们选择一个基于概率论的样本。
- 非概率抽样 —这里我们根据非随机标准选择一个样本，并不是群体中的每个成员都有机会被包含在内。
随意采样
在随机抽样的情况下，群体中的每一个成员被选中的概率都是相等的。下图显示了相同的图示——所有点共同代表整个群体，其中每个点都有同等的机会被选中。
随意采样
您可以使用 python 实现它，如下所示—
***import****random**population = 100* *data* ***=*** *range(population)**print(random.sample(data,5))
> 4, 19, 82, 45, 41*
分层抽样
在分层抽样中，我们根据一些共同的属性将整个人口分成子人口。例如——典型的 ML 分类任务中的类标签。然后，我们分别从这些组中随机抽样，这样组仍然保持与它们在整个群体中相同的比例。下图显示了相同的图形视图——我们有两个基于颜色的计数比率为 x 和 4x 的组，我们分别从黄色和绿色组中随机取样，并以这些组的相同比率代表最终组。
分层抽样
使用 python sklearn lib 可以非常容易地实现它。如下图—
*from sklearn.model_selection import train_test_split
stratified_sample, _ = train_test_split(population, test_size=0.9, stratify=population[['label']])
print (stratified_sample)*
没有 lib 也可以实现它。， 看这个 。
巢式抽样法
在整群抽样中，我们将整个人口划分为子群，其中，每个子群都具有与总体相似的特征。此外，我们随机选择整个子群，而不是对个体进行抽样。从下图中可以看出，我们有 4 个具有相似属性(大小和形状)的簇，我们随机选择两个簇并将其作为样本。
巢式抽样法
现实生活中的例子——120 名学生分成 12 个小组进行一个共同的班级项目。像(名称、类别、主题)这样的聚类参数在这里也是相似的。
你可以用 python 实现它，如下所示—
*import numpy as np**clusters=5
pop_size = 100
sample_clusters=2**#assigning cluster ids sequentially from 1 to 5 on gap of 20
cluster_ids = np.repeat([range(1,clusters+1)], pop_size/clusters)**cluster_to_select = random.sample(set(cluster_ids), sample_clusters)**indexes* *= [i for i, x in enumerate(**cluster_ids**) if x in* *cluster_to_select**]**cluster_associated_elements = [el for idx, el in enumerate(range(1, 101)) if idx in indexes]**print (cluster_associated_elements)*
系统抽样
系统抽样是指以规则的预定间隔 (基本上是固定的和周期性的间隔)从总体中抽取项目。例如——每隔 5 个元素、21 个元素等等。一般来说，这种抽样方法比传统的随机抽样方法更有效。下图显示了相同的图形视图——我们按顺序对第 9 个和第 7 个元素进行采样，然后重复这个模式。**
系统抽样
您可以使用 python 实现它，如下所示—
*population = 100
step = 5**sample = [element for element in range(1, population, step)]
print (sample)*
多级采样
在多级采样下，我们将多个采样方法一个接一个的堆叠起来。例如，在第一阶段，可以使用聚类抽样从总体中选择聚类，然后我们可以执行随机抽样，从每个聚类中选择元素以形成最终集合。下图显示了同一产品的示意图—
多阶段取样
你可以用 python 实现它，如下所示——
*import numpy as np**clusters=5
pop_size = 100
sample_clusters=2
sample_size=5**#assigning cluster ids sequentially from 1 to 5 on gap of 20
cluster_ids = np.repeat([range(1,clusters+1)], pop_size/clusters)**cluster_to_select = random.sample(set(cluster_ids), sample_clusters)**indexes* *= [i for i, x in enumerate(**cluster_ids**) if x in* *cluster_to_select**]**cluster_associated_elements = [el for idx, el in enumerate(range(1, 101)) if idx in indexes]**print (random.sample(cluster_associated_elements, sample_size))*
方便取样
在方便取样的情况下，研究人员只包括那些最容易接近并有时间参与研究的个人。下图显示了相同的图示视图——蓝点是研究人员，橙点是橙色附近最容易接近的人群。
方便抽样
自愿抽样
在自愿抽样的情况下，感兴趣的人通常通过填写某种形式的调查表格来自己参与。这方面的一个很好的例子是 youtube 关于“你看过这些广告中的任何一个吗”的调查，最近这个调查显示了很多。在这里，进行调查的研究员无权选择任何人。下图显示了相同的图示——蓝色圆点代表研究人员，橙色圆点代表自愿同意参与研究的人员。
自愿抽样
滚雪球抽样
在滚雪球抽样中，通过其他参与者选择最终组，即研究人员要求其他已知联系人寻找愿意参与研究的人。下图显示了相同的图示视图——蓝色圆点是研究人员，橙色圆点是(研究人员的)已知联系人，黄色圆点(橙色圆点的联系人)是准备参与研究的其他人。
滚雪球抽样
此外，如果你对研究论文感兴趣，你可以查看我写的一些研究论文摘要。
我希望你喜欢读这篇文章。如果你愿意支持我成为一名作家，可以考虑注册成为的媒体成员。每月只需 5 美元，你就可以无限制地使用 Medium
所以，这就是我的博客。感谢您的宝贵时间！
你应该尝试的 8 个有用的 Jupyter 笔记本扩展
大蟒
借助这些扩展，充分利用 Jupyter 笔记本电脑的优势
Python 库非常受欢迎，让我们的生活变得更容易，使用 Python 的一种流行方式是使用 Jupyter Notebook。尽管 Python 库很棒，但 Jupyter Notebook 提供了一些很棒的扩展，我强烈建议您尝试一下。今天，让我们来探索 8 个我最喜欢的扩展，它们会让你的生活变得更简单。
如果你正在阅读这篇文章，我相信你已经熟悉了 Jupyter 笔记本。如果你不是，下面是他们的网站对此的评论。
Jupyter Notebook 是一个开源的 web 应用程序，允许您创建和共享包含实时代码、等式、可视化和叙述性文本的文档。用途包括:数据清理和转换、数值模拟、统计建模、数据可视化、机器学习等等。
装置
安装扩展只需要一行代码。只需在终端上键入以下代码，就可以开始了。
pip install jupyter_contrib_nbextensions && jupyter contrib nbextension install
现在，如果你在你的终端输入jupyter notebook，一旦屏幕加载，你会在顶部发现一个新的标签。只要点击Nbextentions，就会加载一个有多个选项的新屏幕。让我们探索其中的一些。
作者图片
拼写检查器
Jupyter Notebook 的一个好处是，你可以很容易地在上面批注。然而，它没有提供一个本地拼写检查器，语法上也不支持它。我在项目中看到过一些糟糕的错别字(包括我的)，如果他们使用了spellchecker，这些错别字本来是可以避免的。
幸运的是，扩展拼写检查器提供了一个解决方案。如果你犯了一个错别字，它会突出拼写错误的单词。不幸的是，它并没有告诉我们到底出了什么问题。然而，这总比没有好。要启用它，点击Nbextensions选项卡并选择spellchecker。
作者图片
执行时间
ExecuteTime 向我们展示了一个单元运行的时间。如果这是你关心的问题，那就方便了。在我看来，这对于机器学习是必不可少的，因为模型可能需要几个小时才能运行。你可以争辩说我们可以用 %time 来代替，但是 Jupyter Notebook 提供了更好的体验。要启用它，点击Nbextensions选项卡并选择ExecuteTime。
作者图片
可折叠标题
这个可以很好的帮助你整理你的笔记本。它会根据标题级别自动组织您的笔记本。如果您不需要查看部分代码，您可以隐藏它们，专注于您当前正在进行的工作。要启用它，点击Nbextensions选项卡并选择Callapsible Headings。
作者图片
代码美化
我见过的被人们忽视的最常见的 Python 最佳实践之一是让 Python 代码变得美观易读。当我们没有使用适当的间距时，我们的代码会看起来杂乱无章。即使它完美地工作，一些人可能仅仅因为你的代码的样子就认为你不是一个好的程序员。
Code Prettify 的作用和它暗示的一样:它让混乱的代码看起来更好。一键点击，瞧。如果你是一个在输入代码时不经常使用空格的人，这个扩展会很方便
Code Prettify 的作用和它暗示的一样:它让混乱的代码看起来更好。一键点击，瞧。你的代码看起来会更好，更容易阅读。要启用它，点击Nbextensions选项卡并选择Code prettify。
图片由 ipython-contrib 提供。来源。
腹地
如果你像我一样，在记忆一些必要的代码方面有问题，那么 background 也非常方便。你需要做的就是开始输入，它会根据你输入的字母向你建议一些选项。要启用它，点击Nbextensions选项卡并选择Hinterland。
作者图片
隐藏所有输入
这个扩展隐藏了代码，这样您就可以专注于图形和输出。当我在 Jupyter 笔记本上交付一个项目时，我才明白它的实用性，而观众并不太懂技术。他们只分析图表，不分析代码。要启用它，点击Nbextensions选项卡并选择Hide input all。
作者图片
移动选定的单元格
移动选中的单元格是这个列表中最有用的扩展之一。顾名思义，你可以移动多个单元格。我数不清有多少次我想移动几个细胞，我不得不一个接一个地做。如果我以前知道的话，这个延长会节省我几分钟的时间。
要选择多个单元格，需要按alt + up或alt + down。要启用它，点击Nbextensionstab并选择Move selected cells。
作者图片
橡皮带
你认为上面的扩展对你来说不够好吗？然后橡皮筋会完成这项工作。橡皮筋通过按住Shift并用鼠标选择来帮助你选择单元格。唯一的缺点是，一旦你移动单元格，橡皮筋将取消选择它们。因此，您只能移动选定的单元格一次。要启用它，点击Nbextensions选项卡并选择Rubberband。
最后的想法
Python 库非常酷，但是很多人忽略扩展是事实。扩展可以帮助我们更有效地完成项目。有几十种扩展可供您使用，我强烈建议您阅读每一种。有些可能对我没用，但对你可能有好处。找出答案的最好方法是尝试。
让我知道你喜欢哪些扩展或者我应该在这里提到的任何扩展。编码快乐！
以 8 种方式通过部分字符串或模式过滤熊猫数据帧
如何检查数据帧并只返回所需的行
过滤数据帧是指检查其内容并只返回符合特定标准的内容。这是被称为数据争论的数据分析任务的一部分，使用 Python 的熊猫库可以有效地完成。
这个想法是，一旦你过滤了这些数据，你就可以单独地分析它们，获得对这个组来说可能是独特的见解，并告知项目向前发展的预测建模步骤。
在本文中，我们将使用Series.[isin()](https://pandas.pydata.org/docs/reference/api/pandas.Series.isin.html)和Series.str.[contains()](https://pandas.pydata.org/docs/reference/api/pandas.Series.str.contains.html)等函数来过滤数据。我尽量少用apply()和Lambda函数，它们使用了更多的代码，让包括我在内的许多人感到困惑。但是，我将解释代码并包含相关文章的链接。
我们将使用来自 Kaggle 的网飞数据集，其中包含电视节目和电影的详细信息，包括title、director、cast、上映日期rating、year 和duration。现在让我们导入所需的库并将数据集加载到 Jupyter 笔记本中。
import pandas as pddata = pd.read_csv('netflix_titles_nov_2019.csv')data.head()
作者的网飞数据框架
1.筛选与列中给定字符串匹配的行
这里，我们希望根据特定列的内容进行过滤。我们将使用 Pandas 的Series.isin([list_of_values] )函数，它为列中与完全匹配的每个元素返回一个True 的“掩码”,如果它与isin()函数中的任何列表值都不匹配，则返回False。请注意，即使只有一个值，也必须始终将这些值放在方括号中。
mask = data['type'].isin(['TV Show'])#display the mask
mask.head()
作者图片
然后我们将这个掩码应用于整个数据帧，返回条件为True的行。请注意，上面掩码为True的索引位置是下面过滤后的数据帧中唯一返回的行。
#Display first 5 rows
#of the filtered datadata[mask].head()
注: df.loc[mask]生成的结果与df[mask]相同。当您想要选择几列来显示时，这尤其有用。
data.loc[mask, ['title','country','duration']]
作者图片
生成上述遮罩的其他方式；
- 如果您不想在
isin()函数中处理大写字母和小写字母的混合，首先将该列的所有元素转换成小写字母。
mask = data['type'].str.lower().isin(['tv show'])
- 我们还可以使用==相等运算符来比较两个对象是否相同。这将比较列中的每个元素是否等于所提供的字符串。
mask = (data['type'] == 'TV Show')
- 我们可以提供一个类似于
isin([‘str1’,’str2'])的字符串列表，并检查一个列的元素是否匹配其中的任何一个。下面的两个掩码返回相同的结果。
mask = data[’type’].isin([’Movie’,’TV Show’])#ormask = (data[’type’] == 'Movie’) | (data[’type’] == 'TV Show’)
返回的掩码将全部为 Trues，因为“类型”列只包含“电影”和“电视节目”类别。
2.筛选存在部分字符串的行
这里，我们想检查一个列中是否存在子字符串。
例如，‘listed-in’列包含每部电影或节目所属的流派，用逗号分隔。我想过滤并只返回那些有“恐怖”元素的，因为现在万圣节就要到了。
我们将使用字符串方法Series.str.contains(‘pattern’, case=False, na=False)，其中‘pattern’是要搜索的子字符串，而case=False表示不区分大小写。na=False表示列中的任何NaN值都将返回 False(表示没有模式),而不是从掩码中删除布尔身份的NaN。
mask = data['listed_in'].str.contains('horror', case=False, na=False)
然后，我们将对数据应用掩码，并显示过滤后的数据帧的三个样本行。
data[mask].sample(3)
作者图片
其他示例:
- 我们还可以检查列中是否存在符号。例如，
‘cast’列包含由逗号分隔的参与者，我们可以检查只有一个参与者的行。这是通过用逗号(，)检查行，然后使用波浪号(~)对数据应用过滤掩码来否定语句。
mask = data['cast'].str.contains(',', na=False)data[~mask].head()
作者图片
但是现在这些结果有了NaNs,因为我们使用了na=False,波浪号返回掩码为假的所有行。我们将使用[df.dropna](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.dropna.html)(axis=0, subset=’cast)对数据进行过滤。我们使用axis=0来表示行方式，因为我们希望删除行而不是列。subset=[‘cast’]仅检查该列的NaNs。
data[~mask].dropna(axis=0, subset=['cast'])
作者图片
注意:要检查特殊字符，如+或^，使用regex=False(默认为True)，这样所有字符都被解释为普通字符串，而不是正则表达式模式。您也可以使用反斜杠转义字符。
df['a'].str.contains('^', regex=False)#ordf['a'].str.contains('\^')
3.使用两个部分字符串中的任意一个(OR)筛选行
您可以检查是否存在任何两个或以上的字符串，如果存在任何字符串，则返回True。
让我们看看“恐怖片”或“单口喜剧”来补充每次观看后的情绪状态。
我们使用str.contains()并传递由竖线(|)分隔的两个字符串，竖线表示“或”。
pattern = 'horror|stand-up'mask = data[’listed_in’].str.contains(pattern, case=False, na=False)data[mask].sample(3)
作者图片
- 我们也可以使用长格式，创建两个掩码，并使用
|将它们传递到我们的数据中。
作者图片
注意:您可以创建许多掩码，并使用符号|或&将它们传递到数据中。&表示当两个掩码都为真时组合掩码并返回True，而|表示当任意一个掩码为True时返回真。
mask1 = (data['listed_in'].str.contains('horror', case=False, na=False))mask2 = (data['type'].isin(['TV Show']))data[mask1 & mask2].head(3)
按作者筛选的数据框架
4.过滤两个字符串都存在的行(AND)
有时，我们希望检查一列的元素中是否出现了多个子字符串。
在这个例子中，我们将搜索在美国和墨西哥拍摄的电影。
- 代码
str.contains('str1.*str2')使用符号.*来搜索两个字符串是否严格按照顺序出现，其中str1必须首先出现以返回 True。
pattern = 'states.*mexico'mask = data['country'].str.contains(pattern, case=False, na=False)data[mask].head()
作者图片
请注意,“美国”总是首先出现在筛选的行中。
- 在顺序不重要的情况下(墨西哥可以出现在一行中的第一个)，使用
str.contains('str1.*str2|str2.*str1').。|表示“返回str1最先出现的行，或者str2最先出现的行”。
pattern = 'states.*mexico|mexico.*states'mask = data['country'].str.contains(pattern, case=False, na=False)data[mask].head()
作者图片
请看“墨西哥”如何出现在第四行的第一个位置。
- 您还可以为每个国家创建一个掩码，然后使用
&符号将掩码传递到数据中。下面的代码显示了与上面相同的数据帧。
mask1 = (data['country'].str.contains('states', case=False, na=False))
mask2 = (data['country'].str.contains('mexico', case=False, na=False))data[mask1 & mask2].head()
5.筛选特定列中带有数字的行
我们可能还想使用 regex 模式‘[0–9]’检查列中的数字。代码看起来像str.contains(‘[0–9]’)。
在下一个示例中，我们希望检查年龄等级，并返回破折号后的特定年龄，如TV-14, PG-13, NC-17，而忽略TV-Y7和TV-Y7-FV。因此，我们在数字模式前添加一个破折号(-)。
pattern = '-[0-9]'mask = data['rating'].str.contains(pattern, na=False)
data[mask].sample(3)
作者图片
6.筛选部分字符串出现在多列中的行
我们可以检查子字符串出现在两个或更多给定列中的行。
- 例如，让我们检查“tv”在三列(
‘rating’,’listed_in’和’type’)中的存在，并返回它在所有中存在的行。最简单的方法是为特定的列创建三个掩码，并使用表示“and”的符号&过滤数据(如果至少在一列中，使用| symbol 返回 True)。
mask1 = data['rating'].str.contains('tv', case=False, na=False)mask2 = data['listed_in'].str.contains('tv', case=False, na=False)mask3 = data['type'].str.contains('tv', case=False, na=False)data[mask1 & mask2 & mask3].head()
作者图片
请查看“tv”是如何出现在上面经过筛选的数据的所有三列中的。
- 另一种方法是使用稍微复杂的 apply()和 Lambda 函数。阅读文章 Lambda 函数和 Python 中的实际例子，了解这两个函数是如何工作的。
cols_to_check = ['rating','listed_in','type']pattern = 'tv'mask = data[cols_to_check].apply(
lambda col:col.str.contains(
pattern, na=False, case=False)).all(axis=1)
上面的掩码代码表示，对于列表中的每一列cols_to_check，应用str.contains('tv')函数。然后使用.all(axis=1)将三个掩码合并成一个掩码(或列)，方法是为每一行返回True，其中所有列都是True。(使用.any()返回True表示出现在至少一列中)。
熊猫。所有()和。作者的任何()
过滤后的数据帧与之前显示的数据帧相同。
7.筛选一列中的值出现在另一列中的行。
我们可以检查一列中的值是否作为部分字符串出现在另一列中。
使用我们的网飞数据集，让我们检查一下‘director’作为演员也出现在‘cast’中的行。
在这个例子中，我们将使用df.apply()、lambda和['in’](https://www.w3schools.com/python/ref_keyword_in.asp)关键字来检查某个值是否出现在给定的字符串序列中。
mask = data.apply(
lambda x: str(x[’director’]) in str(x[’cast’]),
axis=1)
上面的[df.apply()](https://www.datacamp.com/community/tutorials/pandas-apply)有一个 lambda 函数，它表示对于每一行(x)，检查‘director’ 中的值是否出现在‘cast’列中，并返回True或False。我用str()包装这些列，将每个值转换成一个字符串，因为它可能因为NaNs而引发了一个[TypeError](https://www.geeksforgeeks.org/handling-typeerror-exception-in-python/) 。我们使用axis=1来表示列方式，因此对每一行进行操作，结果将是一列(或系列)。
data[mask].head()
作者应用()后的 NaNs
哎呦！NaNs真多。让我们使用导演栏作为subset来删除和并重新显示。
data[mask].dropna(subset=['director'])
导演由作者出演
关于检查一列中的值是否与另一列中的值匹配的其他方法，请阅读本文。
8.检查给定子字符串的列名(或索引值)
我们可以检查列标题中是否存在部分字符串，并返回这些列。
过滤列名
- 在下面的例子中，我们将使用
[df.filter](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.filter.html)(like=pattern, axis=1)返回具有给定模式的列名。我们也可以用axis=columns。请注意，这将返回过滤后的数据，并且不会生成掩码。
data.filter(like='in', axis=1)
带有“in”子字符串的已筛选列名
- 我们也可以使用
df.loc,在这里我们显示所有的行，但是只显示带有给定子字符串的列。
data.loc[:, data.columns.str.contains('in')]
这段代码生成的结果和上面的图片一样。阅读这篇文章，了解.loc如何工作。
按指标值过滤
让我们先把标题设为索引，然后按‘爱’字过滤。我们将使用与上面相同的方法，只是稍作调整。
使用df.filter(like=’Love’, axis=0)。我们也可以用axis=index。
df = data.set_index('title')df.filter(like='Love', axis=0)
用“爱”过滤索引
使用df.loc[]显示与上述相同的结果。这里，我们在[.loc](/8-pandas-functionalities-for-every-data-scientist-f2cd3d890795) 的第一部分选择所需的行，并在第二部分返回所有列。
df.loc[df.index.str.contains('Love'), :]
其他过滤方法
- 使用熊猫查询()函数
这是 SQL 忍者特别青睐的一种数据过滤方式。语法是df.query(‘expression’)，结果是一个修改的数据帧。很酷的一点是，除了像前面那样按单个列进行过滤之外，您还可以引用一个局部变量，并在表达式中调用 mean()之类的方法。它还提供了其他复杂遮罩的性能优势。
#Example
data.query('country == "South Africa"')
按作者筛选查询
我自己很少使用这种方法，但是很多人觉得它更简单，可读性更好。我鼓励你探索更多，因为它有令人信服的优势。这篇和这篇文章是一个很好的起点。
- 使用其他字符串(Series.str .)示例函数
这些方法还可以过滤数据以返回掩码
Series.str.len() > 10Series.str.startswith(‘Nov’)Series.str.endswith(‘2019’)Series.str.isnumeric()Series.str.isupper()Series.str.islower()
结论
作为一名数据专家，您可能经常需要根据数据的内容来分离数据。在本文中，我们研究了通过列中的字符串值过滤数据帧的 8 种方法。我们使用了熊猫、Lambda函数和‘in’关键字。我们还使用了|和&符号，以及波浪号(~)来否定一个语句。
我们知道这些函数返回一个掩码(一列)的True和False值。然后，我们使用方括号(如df[mask])或使用。类似df.loc[mask]的锁定功能。你可以从 Github 下载完整的代码。
我希望你喜欢这篇文章。每当我发表新的文章时，想要收到更多这样的文章，请在这里订阅。如果你还不是一个媒体成员，并且愿意支持我成为一个作家，请点击这个链接，我将获得一小笔佣金。感谢您的阅读！
参考
8 种严重混淆数据的方法——而你自己却不知道
业内笔记
您和您的数据可能会发现自己的尴尬处境
雅各布·罗森在 Unsplash 上的照片——由劳伦·普雷兹比潦草地写出脏话
有多少次你偶然发现了一个大规模的数据质量问题，而这个问题几个月都没有被发现，或者直到最糟糕的时候才被发现？作为一名为一些知名政府和行业客户构建分析的专业大数据工程师，我不认为我可以公开承认我有多少次。
我承认，清理数据库真的很糟糕。如果你是那个被键盘卡住的可怜人，你必须在你的头脑中逆向工程你的整个管道。"这些数据究竟是怎么得到的？"“如果我……修好它会怎么样？哦，是的……如果不彻底毁掉那边的另一个东西，那就不行了。”“如果我用整个周末的时间在客户不使用系统的情况下解决所有这些问题，问题会在周一再次出现吗？”“为什么我们的实施团队没有抓住这一点？”“客户读过我们的数据规格吗？”只要有足够的时间和努力，并为自己犯下的可耻错误向客户道歉，你几乎总能控制住局面，但这一点也不好玩。
数据灾难 1:完整性灾难
作为一名软件工程师，您可能有过的最可爱、最聪明的想法之一是基于其他字段的散列为一个事件创建一个唯一的 ID。不能相信时间戳是唯一的？用用户名散列那个混蛋。如果用户可能同时做两件事——添加一个源属性。所以现在你的 ID 有点像HASH(timestamp + username + source)。这应该可以了。
你最好检查一下，确保timestamp、username、source100%完整(也就是没有null数据)。否则，您会发现每个系统帐户操作(碰巧有null用户名，可能每秒钟发生多次)或可能散列到同一个 ID，导致覆盖和可跟踪性的损失。如果数据没有时间戳，那么您现在就真的完成了——祝您好运解开这个混乱。
数据灾难 2:覆盖阴影
你是否曾经在搜索框中输入一个查询，却没有找到你想要的东西？无论是谷歌搜索返回给你一个来自城市词典的不合理的结果，还是 giphy 查询返回一些真正奇怪的东西，你都直接或通过 API 与一个你无法预测的数据库进行了交互。
JOSHUA COLEMAN 在 Unsplash 上拍摄的照片
除了随机查询，你可能写的一个典型的数据库查询是“给我昨天的所有数据”，然后你将通过你的日常分析运行它。这个查询可能看起来非常简单，确实如此，但是如果您不完全理解数据是如何填充的，您可能会错过一些东西。
select * from LOG_TABLE where LOG_TIME >=`2021–09–09` AND LOG_TIME < `2021–09–10`
例如，假设这个系统正在从一个分布式系统中聚集日志。在该系统中，有些设备始终保持连接并传输数据，而其他设备有时会断开连接或在报告时有某种延迟(例如，手机只有在连接到 wifi 时才会共享数据)。您可能没有意识到 LOG_TIME 是源事件发生的时间，而不是数据加载到数据库的时间。
这导致了以下顺序:(1)日志事件发生(2)数据库查询发生(3)日志事件加载到数据库中。在您阅读文档之后，您可能会意识到您应该查询以获得所有结果的字段是 LOG_DX_EVENT_TIME。
咄！
希望您将要编写并交付给客户的三年回填查询不会引发太多关于您可能错过了什么的问题。但是，这是你现在必须为 100%的数据覆盖率付出的代价。
数据灾难 3:整合异常
我在一个有趣的时代开始了我的职业生涯，网络服务革命，所有的数据交换都将通过自我描述的 XML 来促进，这些 XML 遵循由本体学家联盟定义的崇高标准。XML 不仅产生了像 AJAX 和 SAX 这样有趣的名字，还意味着我们再也不用处理定义松散的逗号分隔的文本文件，以及选择分隔符和转义引用字符串带来的所有麻烦。幸运的是，现在唯一使用 CSV 的人…绝对吓坏了所有人。
好吧，所以我们至少在下一个永恒中被 CSV 困住了，现在我们需要想出如何应对。父母们，一旦你们觉得你们的孩子已经准备好阅读章节书籍，请阅读它们。这是很好的夜间阅读，肯定能诱导睡眠，同时帮助你的孩子在平面文件输出的可怕世界中导航。
作者照片
对于那些不明白的人，我说的是这个。让我们假设您有一个从您最喜欢的数据库导出的表。(MSSQL Server 可能是我个人最喜欢的创建 janky CSV 输出的工具。)
Record ID,Name,Role,Home Address
1,Dan,Software Engineering Director,[Qualytics](https://qualytics.co/?utm_source=TDS.Blog&utm_medium=blog&utm_campaign=TDSblogDD9.21.21&utm_id=TDSblogDD9.21.21) Field Office 3
2,Sam,Asst. to the "Dir, SW Engineering",321 Cowboy Commit Ln. Baltimore MD
现在你做到了。由于额外的逗号和缺少正确的引用，记录 2 要么会破坏您的系统，要么会给出五列，这取决于您的错误处理。不管是哪种情况，Sam 现在居住在软件工程深渊的某个地方，远离他在 Cowboy Commit Ln 的甜蜜的家。
老实说，XML 也有很多一致性问题，JSON 也不是完美的，但是我敢打赌，如果你知道去哪里找，你会在你的 CSV 数据中找到各种各样的一致性问题。
数据灾难 MUD 的一致性
突击测验，你能找出这两个日期之间的三个不同点吗？
2021–09–10T6:10:54 and 2021–09–10T10:10:54.0Z
你猜怎么着，它们代表了我写这篇文章前 12 个小时完全相同的时间。然而，假设您的客户最近加入了一个新的团队成员，他没有花几天或几周的时间来学习 Java 时间格式表达式的细微差别。他们可能会忽略东部时间上午 6 点(与 UTC 时间上午 10 点相同)应该表示为 06。或者，他们可能不知道 Z 代表祖鲁，这是本初子午线的航空术语，恰好是我们在皇家格林威治天文台的朋友的当地时间。甚至不要让我开始谈论 0.0 和你可以忍受的 0.0 秒的痛苦。
希瑟·扎布里斯基在 Unsplash 上拍摄的照片
为什么我们要如此详细地讨论日期格式？我曾经有客户在他们当地时间的末尾加了一个“Z ”,因为我们的规范说应该有一个。客户交付的数据在上午 6 点和下午 6 点的时间戳之间完全没有差异。我见过在凌晨 1 点到 10 点之间丢弃所有数据的系统，因为“6 应该是 06”的问题。
顺便说一句，除非你在夏威夷、亚利桑那或委内瑞拉，否则有一种东西叫做夏令时。大约在圆周率日的某个时候，你可能会意识到你的系统一直配置错误。是时候拿出你的旧的时移再处理脚本，在公司日历上安排一些停机时间了。
无论您在哪里发现日期/时间格式或配置问题，您都会发现每个系统之间缺乏数据一致性。分析系统中的事件可能在它们实际发生时的几个小时之前被表示出来。祝您在与最终用户的支持电话中解释这一点时好运。
数据灾难 5:重复复制
上周一，一切都太棒了。您的团队刚刚实现了新的年度经常性收入(ARR)目标，并完成了一个重要的新里程碑。你的柱形图高高耸立，让区分赢家和输家的虚线黯然失色。你在每周全体会议上自豪地宣布了团队的优秀，并祝贺每个人和他们亲爱的母亲给这个世界带来了快乐。你首先倒了一杯威士忌，向公司创始人敬酒，感谢所有给你机会领导这个神奇团队的人。
ID 173831557 瓦迪姆·克鲁奇尼克|Dreamstime.com
现在距离周一的会议还有 20 分钟，你刚刚意识到…一个大客户的销售合同条款搞砸了你的进口，包括上季度和本季度的全部收入数字。你的累计总和离还差得很远——你现在远未达到目标，而且情况看起来根本不可能在本季度达到你的数字。
你现在打算做什么？承认错误？把销售助理扔到公共汽车下面？修好它，希望没人注意到？归咎于报告工具的小故障？明天修好，下周一走？这些都是有趣的选择(除了坦白)，但它们都伴随着你的替代者必须处理的后果。下次你也许应该检查你的数据是否重复。
数据灾难 6:时效性不佳
对于您的最终用户 Martha 来说，这是一个美好的早晨，她的早晨通勤没有交通堵塞，自动咖啡机充满了水，没有咖啡渣，她的计算机不到 10 分钟就启动了。她已经准备好去度过她整个职业生涯中最有成效的一天。
玛莎导航到您的 web 应用程序。
"没有新的通知。"
好吧，我想是时候去抖音了。
事实是…流入你系统的数据错过了截止窗口。由于客户应用程序数据库的软件升级，自动提取被延迟到早上。转换和加载逻辑努力等待提取。然而，您的分析在午夜运行，因为它总是这样，以避免大量的数据库使用。没有新数据，没有新警报。玛莎没有工作。
值班人员在早上 6 点得到了没有警报的消息，但是他们正在处理 CSV 格式的问题。当客户数据库管理员记得手动执行提取时，数据在上午 9 点交付……当随叫随到人员查看页面时，数据已经在那里——根据随叫随到人员的不同，问题要么会一直上报给 CEO，要么会被忽略。
希望您的系统足够智能，能够在新数据到达时触发，或者在几天后处理这些不合时宜的数据问题。玛莎明天会很忙。
数据灾难 7:体积悖论
你曾经写过一个你真的真的不会错过任何信息的软件吗？假设这是一个访问控制系统，员工每次进出安全实验室使用计算机时，都必须在读卡器中扫描他们的徽章。如果没有，您的软件将在一天结束时检查日志，并确定存在安全违规。第二天，一名保安和他们友好的“人员问题”团队的一名成员将拜访已确定身份的员工，与他们聊天。
如果有一天“人的问题”的人打电话给你，系统所有者，问你是否绝对确定有 10 倍多的人溜进了那个实验室，而几乎同样多的登记用户却无处可寻，那该怎么办？他们说他们已经面试了三个人，并发誓他们登录正确。你看看你的报告——昨天确实有很多违规者——也许他们在集体烧烤时喝多了。或者等等……为什么从 5:30 到 6:00 没有出入卡。
照片 225456464 暗黑 1 自己|【Dreamstime.com】T4
嗯，事实证明，在那段时间有一个系统重新部署。队列中的消息肯定已经丢失。没有人会注意到，因为它是在你慢慢放松的门槛内，以解释常规的星期五逃学。但是……对于周三来说，这是相当少的交通流量。
这是一个非常真实的例子，说明不成熟的容量检查会让数据质量问题渗透到您的系统中，并引发一系列问题，使您的用户，最终是您的团队陷入困境。
数据灾难 8:准确性灾难
你可能在最近的新闻中听说过，这是真的，地球不是圆的。我是认真的——不是圆的。甚至不是扁球体。有时候这里非常平坦，有很多海龟。
好的，实际上地球是一个大地水准面，一个不规则形状的凸起。这就引出了一个问题，“你现在有多高？”不，这不是一个关于你是如何在博客的结尾提到数据质量的问题。这是合法的。你的海拔高度是多少？让我看看你的遥测数据。
想象一下，你有一架可爱的新无人驾驶相机，你想精确定位你在拍摄照片的那一侧山上的确切位置。要做到这一点，你需要相机的方向和角度，加上车辆遥测，加上数学，以获得空中自拍的准确坐标。你不仅需要无人机相对于地面的高度，还需要相对于海平面的高度，以及如何与世界大地测量系统进行比较。否则，搜救队永远也找不到你。
我知道这很令人困惑，我也花了一分钟。别担心，这里有一个很酷的摄像无人机视频。
圣诞清单
你需要知道的是，一个干净的最终结果只有在高度准确的数据下才有可能。尽可能找到最好的数据。检查两遍。预测误差并找到解决方案来解释误差。
结论错觉
如果你是一个纯粹的数据极客，一旦数据完全混乱，实际上有一些有趣的问题需要解决。对于我们这些只想信任我们的数据的人来说，先投资于数据质量检查。如果在你的系统中进行足够的数据检查真的很难做到(事实也的确如此)，那么看看我们在 Qualytics 建立的数据质量分析。
Qualytics 是为您的企业数据生态系统注入信任和信心的完整解决方案。它无缝连接到您的数据库、仓库和源系统，通过异常检测、信号和工作流主动提高数据质量。查看我们的网站，了解更多关于如何开始信任您的数据的信息。
转换熊猫数据帧的 8 种方法
高效数据分析实用指南
由雄心勃勃的创意公司——Rick Barrett拍摄于 Unsplash
Pandas 是 Python 的一个数据分析和操作库。Pandas 的核心数据结构是 dataframe，它以带有标签的行和列的表格形式存储数据。
Pandas 提供了多种功能来修改或操作其核心结构。在本文中，我们将介绍 8 种不同的数据帧转换方法。
我们从导入依赖项开始。
import numpy as np
import pandas as pd
我们将使用下面的示例数据框架来做前几个示例。
(图片由作者提供)
添加/删除列
首要的转换方式是添加或删除列。可以添加一个新列，如下所示:
df['new'] = np.random.random(5)
(图片由作者提供)
我们以数组或列表的形式给出值，并为新列指定一个名称。确保数组的大小与数据帧的大小兼容。
drop 函数用于删除一列。
df.drop('new', axis=1, inplace=True)
(图片由作者提供)
我们传递要删除的列的名称。axis 参数设置为 1，表示我们正在删除一列。最后，inplace 参数需要为 True 才能保存更改。
2.添加/删除行
我们可以使用 loc 方法向 dataframe 中添加一行。
df.loc[5,:] = ['Jack', 3, 3, 4, 5, 1]
(图片由作者提供)
loc 函数指定带有标签的行和列。[5，:]表达式指示标签为 5 的行和所有列。
轴参数设置为零的 drop 函数可用于删除一行。
df.drop(5, axis=0, inplace=True)
我们刚刚删除了上一步中添加的行。
3.插入
insert 函数将一列添加到特定位置。
df.insert(0, 'new', np.random.random(5))
第一个参数指定列索引。第二个和第三个参数分别是列名和值。
(图片由作者提供)
4.熔化
melt 函数将数据帧从宽格式(高列数)转换为窄格式(高行数)。最好通过一个例子来解释。考虑以下数据帧。
(图片由作者提供)
它包含 3 个人的连续每日测量。该数据帧的长格式可以使用 melt 函数实现。
pd.melt(df, id_vars='names').head()
(图片由作者提供)
传递给 id_vars 参数的列保持不变，其他列合并在变量和值列下。
5.串联
concat 函数沿一个轴(索引或列)组合多个数据帧。数据帧的形状必须与轴兼容。
考虑以下两个数据帧。
(图片由作者提供)
下面是我们将它们结合起来的方法:
pd.concat([df, df2], axis=0, ignore_index=True)
(图片由作者提供)
我们将轴参数设置为零，以沿着索引进行组合。ignore_index 参数重置索引。否则，保留原始索引(0，1，2，0，1，2)。
要沿列合并，轴参数设置为 1。
6.合并
Merge 函数还基于给定的一列或多列中的公共值组合数据帧。考虑以下两个数据帧。
(图片由作者提供)
我们可以根据 id 列合并它们。
customer.merge(order, on='id')
(图片由作者提供)
默认情况下，只取两个数据帧中都存在的值。我们可以用“how”参数来改变它。例如，如果我们将 is 设置为“left ”,则从左侧数据帧中获取所有值，并且仅从右侧数据帧中获取匹配的值。
7.拿假人
一些机器学习模型无法处理分类变量。在这种情况下，我们应该对分类变量进行编码，将每个类别表示为一列。
假设我们有以下数据帧。
(图片由作者提供)
get_dummies 函数对 name 和 ctg 列进行编码。
pd.get_dummies(df)
df 编码(图片由作者提供)
例如，在第一行中，姓名是 Jane，ctg 是 a。因此，表示这些值的列是 1，所有其他列是 0。
8.数据透视表
pivot_table 函数将数据帧转换为解释变量之间关系的格式。
(图片由作者提供)
左边的数据框包含两个分类特征(即列)和一个数字特征。
我们希望看到两列中类别的平均值。pivot_table 函数以一种可以清楚地看到平均值或任何其他聚合的方式转换数据帧。
df.pivot_table(index='name', columns='ctg', aggfunc='mean')
(图片由作者提供)
结论
我们已经介绍了转换数据帧的 8 种不同方法。有些只是改变结构，而有些则在转换过程中执行计算。
我们还看到了如何添加或删除行和列。此外，merge 和 concat 函数通过组合数据帧来转换数据帧。所有这些操作都是数据分析和处理过程的重要部分。
感谢您的阅读。如果您有任何反馈，请告诉我。
9 个非常棒的机器学习 Python 包，应该得到更多的赞誉
这些软件包由微软、Yandex、英特尔或较小的组织或个人构建，自动化了机器学习中的许多冗余任务。
介绍
在过去的几周里，我有一些空闲时间，我花时间探索积压的资源。我很惊讶。这么多很酷的——不一定很有名的——关于机器学习的软件包没有登上排行榜的首位。它们的受欢迎程度看起来像利基，尽管它们应对了机器学习中的基本挑战。
所以他们来了。ML 中真正有用的 9 个在工作中学习和实现的包: interpretML 、 dtreeviz 、 CatBoost 、 plaidML 、 mlflow 、 kedro 、 sklearn_pandas、Streamlit 、 pandas_profiling。
它们包含在以下主题中:
- 模型解释 (interpretML，dtreeviz)
- 模型构建 (CatBoost，plaidML)
- 模型产业化 (mlflow、kedro、sklearn-pandas)
- 应用创建 (Streamlit)
- 数据审计 (pandas_profiling)
模型解释
1-InterpretML
由微软作为开源项目开发的 InterpretML 是“一个帮助理解模型并实现负责任的机器学习的工具包”。 4 个包是这个项目的一部分，其中有 2 个是我最喜欢的:
解释(Github 上的 2.7k 星星)允许你建立一个 GA2M 模型(杜撰“可解释的助推机”或“EBM”)用于分类或回归问题。GA2M 是“广义可加性 2 模型”的缩写，它是一族既高度精确又高度可解释的模型。
广义可加模型(或 GAM)方程。模型的最终预测是每个独立变量影响的总和。它被称为“白盒”模型。每个变量的影响可以单独绘制出来，并由人简单地理解。
广义可加 2 模型(或 GA2M)方程。这是 GAM 模型的自然演变，有两个变量的多种组合。这个模型仍然是“白盒”,比经典的梯度增强树模型更容易被人类解释和理解。
这一系列模型几乎与经典的梯度增强树模型(如 LightGBM、CatBoost 或 XGBoost)一样准确，但更具可解释性。在大多数商业问题中，解释是关键，但也意味着不如高级模型准确。这些模型允许您在保持相对较高的可解释性的同时保持较高的准确性。这些肯定会成为机器学习社区的标准，在某种意义上，数据科学家将尝试并实现 GA2M 而不是 XGBoost。
在成人收入数据集( url )上训练的 GA2M(“EBM”)的输出。你可以看到，基于曲线的形状，变量“年龄”的影响是相加的。
更多关于 GA2M 的话题:https://blog . fiddler . ai/2019/06/a-gentle-introduction-to-ga2ms-a-white-box-model/
interpret-community(Github 上只有 123 颗星)是一个将 AzureML 的能力带到开源社区的项目。让我们来看看这个包最有趣的特性:神奇的tabular explaner函数，它允许你:
- 在第三个变量上用彩色编码标出 2 个变量(一个变量也可以是模型的预测值)
- 绘制总体最具预测性的变量
- 画出当地的解释(分别进行单独预测的原因)
- 使用假设情景逻辑运行模拟
而这个在上任意给定的型号上！【注意用户界面对微软非常友好，这是你从私营公司开发的开源软件中得到的:】
由 TabularExplainer 创建的主仪表板允许您可视化您的数据、模型预测和变量重要性。我使用泰坦尼克号数据集，用变量“年龄”(比例)绘制死亡概率，并用性别作为颜色编码。你可以看到，我的模型输出了 5 种不同的死亡概率(除了少数例外)，女性通常低于 50%的概率死亡(红点)，最老的人有超过 50%的概率死亡(“年龄”大于 0.8)
您可以选择一个单独的数据点，并可视化其预测的相对变量重要性。
您可以选择一个单独的数据点，并通过手动更改输入来运行不同的场景。
interpretML 项目的最后两个包，interpret-Text和 DiCE ，分别帮助解释文本分类模型和创建“多样的反事实解释”(这是对给出相反预测的数据点的扰动)。两者看起来都很酷，尽管我还没有时间深入研究它们。
使用解释文本，您可以可视化单个单词对二进制分类模型( url )的影响
2-dtreeviz
无论您使用 XGBoost、Random Forest 还是 CatBoost，您的模型中都内置了树。停止使用 sklearn 丑陋的 plot_tree 函数来显示它们。相反，使用 dtreeviz 。【注一 爱情 sklearn 尽管如此】
这就是 sklearn 的 plot_tree 函数显示的内容。除了糟糕的颜色编码之外，你还必须一盒一盒地阅读来区分大叶子和小叶子。
dtreeviz 在 Titanic 数据集上构建的决策树上的输出。难以置信的透明可视化。
dtreeviz 还具有特定的回归可视化功能，显示阈值的散点图和虚线。
安装它并使它工作可能有点乏味，但它是值得的。你不会回头的。
模型结构
3-催化增强
由 Yandex 开发的这个软件包在准确性、速度和可解释性方面令人惊叹。我写了一篇文章总结了它的能力。数据科学家通常知道 XGBoost，可能不太想了解其他类似的 boosting 库，如 CatBoost 或 LightGBM。但是 CatBoost 有这么多很酷的附加特性(可视化训练、可解释性工具……)，如果默认使用 XGBoost 就太可惜了。
**
4-plaidml
PlaidML 的标志
谁说要买英伟达昂贵的 GPU 才能做深度学习？我自己作为一个深度学习新手，不想只为了学习而去买昂贵的 GPU。而如果 Google Colab 提供了一个很好的替代方案，我还是不想依靠我的互联网连接和 Google 来做深度学习。
这是 PlaidML。由英特尔开发的 PlaidML 旨在让手头没有昂贵 GPU 的人和组织能够访问深度学习。你将能够用你的 MacBook Pro 运行深度学习模型(耶！这就是我得到的！)
一个重要的注意事项，使用它的社区今天看起来不大，设置它有一点挑战，我在下面详述:
我试着为我的 Jupyter 笔记本设置它，不得不克服一些困难(比如这个)。基本上，我已经通过创建一个自定义环境，然后从它启动一个 Jupyter 笔记本来使它工作。下面是详细的步骤:
1.从 JupyterLab 的终端，为 plaidML 创建一个环境并激活它。
conda create --name plaidML
conda activate plaidML
2.安装 plaidML 包
pip install plaidml-keras plaidbench
3.为现有硬件设置首选项
plaidml-setup
您必须在默认设备或实验设备之间做出选择。我在默认设备中选择了一个硬件。
4.从您的常规 Jupyter 笔记本屏幕或使用 JupyterLab 打开 Jupyter 笔记本。
在 Jupyter 笔记本启动窗口中，单击“新建”，然后单击“plaidml”。这将打开一个笔记本，其中包含您刚刚设置的 plaidml 环境。
您还可以在正在运行的笔记本中更改环境(或内核),并选择您新创建的 plaidml env。
5.现在，您可以在笔记本中使用 plaidML，只需两行代码:
import os
os.environ[“KERAS_BACKEND”] = “plaidml.keras.backend”
用...测试它
import keras
它应该会输出类似这样的内容:
给你。快乐深度学习；)
模型工业化
5-mlflow
“机器学习生命周期的开源平台”， ML Flow 允许数据科学家运行实验，使用 API 部署他们的模型，并在集中的注册表中管理他们的模型。它是为工程方面量身定制的(你必须经常使用命令行)，对于数据科学家来说使用起来还是很简单的。
下一步肯定是在 AWS 或云提供商上安装它，看看我— 一个没有计算机科学背景的数据科学家能否让它工作。
我可以在我的机器上测试这个库。我喜欢两个功能，因为与我以前手动操作相比，它非常简单:
- 运行具有不同参数的模型，并使用热图/“等高线图”显示精确度，以确定参数的最佳组合:
将 10 个模型(相同的模型但不同的参数集)与“等高线图”图表进行比较
- 将您的模型部署为 API:
将您的模型部署为 API 就像使用命令行一样简单: > mlflow 模型服务于。我用一个假数据点测试 API，它立即返回预测，就像变魔术一样！
6-凯德罗
Kedro 是一个开源 Python 框架，用于创建可复制、可维护和模块化的数据科学代码。它从软件工程中借用概念，并将它们应用到机器学习代码中；应用的概念包括模块化、关注点分离和版本控制。
我在这上面花了一点时间，但是我还没有把它用于专业项目。根据我的理解，Kedro 主要面向那些专注于设计可维护的数据科学代码的工程师。
Github 回购在这里有:【https://github.com/quantumblacklabs/kedro
7-sklearn-pandas
你有没有尝试过在熊猫身上使用 sklearn，并意识到(艰难地，试图解决奇怪的错误)sklearn 是为 numpy 设计的？然后 sklearn-pandas 送给你！
我在之前的一篇文章里已经讲过了。基本上，它可以帮助您不再浪费时间将数据帧转换为 numpy 数组，然后再转换回数据帧，以使您的 sklearn 管道工作。
ML 应用程序
8-细流
Streamlit，怎么说呢，重新定义了一个数据科学家应该具备的“软技能:)
事实上，它允许数据科学家用 Python 创建漂亮的应用程序，非数据科学家将使用它来尝试机器学习模型。
如果你以前没有尝试过 Streamlit，我估计你会上他们的网站并尽快开始使用它。画廊部分极具启发性。
对我来说，这是交付 ML 模型的新标准。数据科学家不仅应该向数据工程师团队分发模型文件，而且最重要的是向业务团队分发一个演示应用程序来解决这个问题。
对我来说 Streamlit 最大的特点是什么？带空间的扩展！您可以创建与 NER 和其他 NLP 模型交互的漂亮应用程序。这是小菜一碟🍪
数据审计
9-熊猫 _ 简介
我在之前的一篇文章中已经谈过了，所以我不会深究太多。这是我作为 pd 运行 import pandas 后加载的第二个包。
注意你可能会在安装或正确运行它时遇到一些麻烦，因为它依赖于各种其他的包。
感谢阅读！**
寻找机器学习数据集的 9 个最佳地点
机器学习、数据科学和数据可视化的数据集集合
图片由作者提供，许可证由 Envato 持有
机器学习通常被视为这种神奇的工具，在这里您可以洗牌数据，并将获得的知识转化为预测。然而，要做到这一点，你需要收集、清理和合并大量的数据。
今天，我们将简化您的生活，并向您概述可以找到各种用途的聚合数据集的最佳位置。从地理数据到犯罪数据，可以检查的潜在领域非常吸引人。
1.谷歌的数据集搜索引擎
域名:【https://datasetsearch.research.google.com/
与谷歌的核心产品一样，你可以使用文本轻松搜索数据集。此外，您可以按日期、数据格式和使用权过滤查询。该网站上的数据集从公司有偿提供的真实数据集到个人项目免费使用的数据集。
如果你正在寻找一个没有任何特定限制的所有可用数据集的概览，谷歌是最好的起点。
来自谷歌数据集搜索引擎的截图
2.Kaggle 数据集
域名:【https://www.kaggle.com/datasets
如果你曾经参加过任何数据科学相关的课程或黑客马拉松，你可能会遇到 Kaggle。Kaggle 是世界领先的所有数据科学相关编程平台。它还允许用户查找和发布数据集，更重要的是，与其他数据科学人员就如何从中提取价值进行合作和竞争。
如果你想了解更多关于某个特定类型问题的知识，并想与世界各地的数据科学家讨论这些知识，kaggle 是你的不二之选。
3.地球数据
域名:https://earthdata.nasa.gov/
对于那些想有一个高层次的概述的人来说，来自 Nasa 的地球数据是正确的地方。它拥有可能是最大的关于地球、气候和水体的地理相关数据集。
这些数据集是由世界各地的研究人员和机构提供和创建的，肯定是各个领域中最高质量的。如果您正在寻找一个专注于时间序列或地理空间数据的项目，这无疑是开始寻找的最佳地方。
截图来自地球数据
4.亚马逊和微软数据集，Azure 和 AWS
域名 AWS:https://registry.opendata.aws/
domain Azure:https://Azure . Microsoft . com/en-us/services/open-datasets/catalog/？q=
大型科技巨头在他们的开放数据注册中心拥有来自世界各地的数据集。我把它做成一个联合的地方，因为虽然他们没有大量的数据集，但他们有一些特别大的数据集。
他们在云和大数据存储方面的经验肯定会在向公众提供这些数据集时派上用场。目前 AWS 有大约 200 个数据集，Azure 有大约 20 个。
如果您正在寻找大数据领域的项目并希望处理大量数据，这些地方是最佳选择。
5.联邦调查局犯罪数据浏览器
域名:【https://crime-data-explorer.fr.cloud.gov/downloads-and-docs
如果你想知道那些没有很好地注释他们的代码的人会发生什么，FBI 犯罪数据浏览器可能会给你一个提示。可能是围绕犯罪和非犯罪的执法数据的最大的数据收集。它的特点是从基于州的犯罪数据到与人口贩运相关的数据。
虽然这通常是一个悲伤的故事，但它也是最令人兴奋的数据类型之一。如果你正在寻找一个变化和一个新的令人兴奋的项目，有点不同，它肯定是一个金矿。
获得 CC0 许可的 FBI 数据浏览器截图
6.数据世界
一个很少被提及的集合是数据世界。它非常类似于谷歌数据集搜索引擎。然而，我发现这个实现非常令人满意的是搜索深度，当输入一个查询时，它不仅显示数据集本身，还显示可能包含所需数据的子文件。当然，这在寻找诸如人口统计和地理位置收集之类的二手数据时特别有用。
如果你正在寻找一个以数据命名的专门网站，强烈推荐《数据世界》。
7.CERN 开放数据门户
位于日内瓦附近的欧洲核研究组织(CERN)向公众提供了许多令人难以置信的研究数据。
CERN 的开放数据门户很吸引人。他们收集并提供了超过 2pb 的数据，这些数据是关于最小的事物，粒子物理学。这是欧洲最负盛名的研究机构之一，他们关于粒子碰撞的数据质量无人能及。
来自 Cern 许可为 CC0 的开放数据的屏幕截图
8.Lionbridge AI 数据集:
域名:https://lionbridge.ai/datasets/
Lionbridge 是一家提供数据收集、注释和验证服务的公司。除此之外，定制标注环境和我们今天感兴趣的各种数据集都可以通过他们的网站找到。
在他们的数据集部分，他们向你展示了几篇包含各种来源的文章。比如‘11 个最适合机器学习的气候变化数据集’和‘50 个最适合机器学习的免费数据集’。由于他们是一家围绕数据集建立的公司，他们的建议肯定很棒。
如果您正在寻找专门数据集之间的比较，这是最好的地方。
9.UCI 机器学习知识库
域名:【https://archive.ics.uci.edu/ml/index.php
加州大学欧文分校有超过 550 个数据集供你免费使用。我发现这个网站特别有教育意义，因为它提供了问题过滤。因此，分类、回归和聚类，你可以很容易地找到一个数据集，将与你目前正在探索的技术很好地工作。
除了知道如何教育人们，他们的团队肯定知道很多关于机器学习数据集以及如何评估它们的知识。
9:荣誉奖
在 place 9 上，我们有所有的荣誉奖和其他很棒的数据集集合，这是我们无法在一篇短文中涵盖的。我会把它们留给你，让你对它们有一个全面的了解。
数据中心
令人惊叹的数据集
https://github.com/awesomedata/awesome-public-datasets
政府统计网站—例如美国
视觉数据—特别适合图像/视频工作
【https://www.visualdata.io/discovery
结论
正如我们所看到的，数据世界正在迅速膨胀。从犯罪到折纸龙，越来越多的数据集涌现出来，等待人们去探索。
我希望您已经了解了您将在下一个项目中使用的数据集，现在可以围绕如何以及在哪里找到您可能需要的所有数据做出明智的决定。
如果你喜欢这篇文章，我会很高兴在 Twitter 或 LinkedIn 上联系你。
一定要看看我的 YouTube 频道，我每周都会在那里发布新视频。
9 个干净的代码模式，我希望我能早点知道
当你回顾自己职业生涯早期写的代码时，你知道那种感觉吗？我总觉得有点恐怖。但这也有积极的一面:我学到了一些新东西😄
好软件的核心部分是可读性。保持较低的心理复杂度，以便每个人(包括作者)都能轻松理解。干净的代码模式有助于做到这一点。
在本文中，您将了解 9 种清晰的代码模式，它们使代码更易于阅读。请将这些模式视为工具。它们并不总是适用。不要对他们有宗教信仰。我使用的语言是 Python，但是这些模式也适用于 Python 之外。开始吧！
№1:解释变量
这可能是你可以轻松运用的最简单的技巧。如果有些东西很难理解，你需要给它一个评论，试着给它一个名字。
# Bad
if not (
string.startswith('"""')
and string.endswith('"""')
and '"' not in string[3:-3]
):
return string# Good
**is_tripple_quoted_string** = (
string.startswith('"""')
and string.endswith('"""')
)
if not (is_tripple_quoted_string and '"' not in string[3:-3]):
return string
这主要适用于布尔表达式，但也适用于正则表达式，有时也适用于返回值。
№2:遵循惯例和风格指南
每一种编程语言都有一个你需要遵循的语法，否则，它将无法工作。然后还有惯例。你不必跟随他们；它仍然会工作。然而，如果你跟随他们，会让其他人的生活变得更容易。
最简单的惯例之一是风格指南。在 Python 中是 PEP 8 ，谷歌发布了 C++ / Java 、Oracle Java 代码惯例的指南，在 PHP 中有 PSR-1 ，…
其他向导是隐式的。例如，Django 项目是如何构建的。您通常存储视图、模型和模板的地方。
找到与你相关的风格指南，并遵循它们。
通常，也有 linters 或静态代码分析工具帮助你习惯指南。比如 Python 里有flake8，有很多插件。对于最简单的部分，即格式化，您可以使用工具来完成。我喜欢的一个 Python 代码自动套用格式器是黑色的。
№3:类型检查
我喜欢 Python 中的类型注释。它们是可选的，但是我强烈推荐使用它们。在使用方法上也有区别。
例如，如果你有Dict[str, Any]，你可以考虑用NamedTuple / TypedDict / pydantic / dataclasses来代替。
在某些情况下，当你使用str作为类型时，你可能要考虑使用NewType来表示你正在使用哪种类型的字符串。是一个AuthorId吗？是一个UserId吗？
这两种模式也适用于其他语言。让我们这样表述:
善用类型系统。
如果您想了解更多关于 Python 中的类型注释，请阅读:
https://medium.com/analytics-vidhya/type-annotations-in-python-3-8-3b401384403d
如果你想知道最近的改进，请阅读我的 Python 3.10 文章。
№4 一致的术语
我在金融科技公司 Cashlink 工作，是一名 Python 后端开发人员。我们处理数字证券，例如代表真实价值的代币，比如太阳能发电厂的一部分。这些代币可以转让。这里开始变得有趣了。根据转移的类型，我们必须做不同的事情。要么是因为法规，要么是因为技术原因。因此，我们开始为不同类型的转账起不同的名字，以免总是混淆:
- 转移:任何改变平衡的动作。下面的所有条款都是某种转让(虽然我会犹豫要不要打电话给 minting，烧个转让)。
- 造币:代币生成。这种情况首先发生。
- 发行:发行人向投资人的转让。这种情况其次发生。
- Move :从钱包 A 到钱包 B 的转账，其中 A 和 B 属于同一个投资人。
- 交接:从钱包 A 到钱包 B 的一次转账，其中 A 和 B 属于不同的投资人。
- 烧钱:从投资者账户中取出代币。
这些事情很重要，但是还有其他例子，其中的术语可能不同。比如内部的产品名，外部的。营销可能有不同于开发的需求。试着找到一个适合公司大多数人的词汇。
№5 个有意义的名字
把你的代码库想象成一本书。这本书有很多很多不同的故事情节。变量就是字符。你可以在一定程度上依赖上下文，但是如果你把每个人都称为“朋友”，读者会感到困惑。如果仅仅为了名字就需要看半页，他们会很烦。
- 避免太短的名字，比如
i或者x。他们很难找到。如果你写一个数学函数，它们可能是有意义的。 - 避免太长的名字比如
InternalFrameInternalFrameTitlePaneInternalFrameTitlePaneMaximizeButtonWindowNotFocusedState。Java 开发人员经常落入这个陷阱。是的，这个名字可能非常准确。然而，这使得围绕它的所有逻辑都超级难以理解。在x和InternalFrameInternalFrameTitlePaneInternalFrameTitlePaneMaximizeButtonWindowNotFocusedState之间有一个不错的中间地带。 - 与№4 的词汇保持一致。同样在拼写上。决定你是想用美式英语还是英式英语。决定是否要在代码库中编写 display/show/present/print。
- 避免使用像
user_dict这样的名字中的数据结构。如果你需要，那可能是你违反了第 6 条。尽量只使用一个对象的一种表示。但是请记住，这是一个普遍的规则。有时候使用user_dict确实有意义。 - 利用上下文。例如，
java.sql.SQLIntegrityContraintViolation可能只是一个java.sql.IntegrityError。在sql包中，一切都应该是关于 SQL 的。而ConstraintViolation就是一个错误。
迭代时我喜欢的一种模式是使用迭代器的复数形式(以“s”结尾)和单数形式(没有最后的“s”)
# Bad
for tmp in users: ...# Good
for user in registered_users: ...
顺便说一句:如果你在野外看过搞笑的变量命名请分享😄
№6 降压法则
将一个功能保持在一个抽象层次有助于你专注于一个主题。
独立逻辑↔数据收集/传输↔演示。
演示不一定必须是可视化的。它可以是打印语句，也可以是 API 响应。
马雷克·胡季马给举了一个降级规则的好例子。
在 Python 中，当有大量缩进时，有时会看到这种情况。
№7 删除死代码
不存在的代码是无法破解的代码。这是不会引起安全问题的代码。是不需要维护的代码。不要将代码注释掉，而是将其移除。
你可以使用 vulture 和flake 8-根除在 Python 代码库中找到这样的片段。
我知道当你有了以后可能需要的东西时的感觉。我通常会尝试编写一个真正彻底的提交消息，只删除那些注释/文件，以便以后需要时能够找到它。但是有 YAGNI: 你不会需要它的！
8 使用容器
如果您在代码库的几个地方传递相同的几个值，您可能要考虑编写一个容器。那可能是一个类，在 Python 中你可以使用一个数据类、一个命名元组或者一个类型集合。如果您需要序列化它，Pydantic 类也很不错。
应该使用容器格式的一个主要例子是配置。
避免意外
这是显而易见的，但有时很容易忘记。一个核心部分就是避免副作用。应该清楚函数是否改变状态。另一部分是对文件的黑客攻击。有时有黑客是必要的，但至少留下一个为什么有黑客的评论。
不要试图做一些聪明的事情。遵循接吻原则——保持简单和愚蠢！
摘要
写好代码就像写好文章一样:它需要练习，你会不断进步。大量阅读，寻求反馈并鼓励人们在反馈中也给出小的笔记。那些没太大关系，只是个人喜好的。
最后，明白自己读代码讨厌什么。避免那些模式😄—但是应用这个😍练习，接受反馈，对你的代码持批评态度。然后你会成为一名出色的软件工程师🥂
我喜欢写关于软件开发和技术的文章🤩不要错过更新: 获取我的免费电子邮件简讯 📧或者如果你还没有报名参加 medium✍️——这两者都鼓励我写更多🤗
ML 中数据集选择的 9 大罪
通过预先关注数据集，避免模型调试中的无尽痛苦
让我们从一个显而易见的事实开始:ML 模型只能和用来构建它们的数据集一样好！虽然有很多对 ML 模型构建和算法选择的强调，但团队往往没有足够重视数据集选择！
根据我的经验，前期在数据集选择上投入的时间可以在模型调试和产品展示过程中节省大量时间。
九宗罪的 ML 数据集选择
1。没有正确处理数据集中的异常值
基于正在构建的 ML 模型，离群值可以是忽略的噪声，也可以是必须考虑的重要因素。由收集错误引起的异常值需要被忽略。机器学习算法对离群值的敏感度不同，与 XgBoost 相比，AdaBoost 对离群值更敏感，而 XgBoost 比简单地将离群值视为错误分类的决策树更敏感。正确处理异常值需要了解它们是否可以被忽略，然后根据敏感度选择合适的算法。
2.使用归一化而不是标准化来缩放特征值
要使要素具有相同的比例，请在数据均匀分布时使用归一化(最小最大比例),在要素近似为高斯分布时使用标准化(标准比例)。在使用数据集之前，验证 iid 的属性，静态(不随时间变化)，并确保在训练和测试期间具有相同的分布。季节性经常被忽略，这是对平稳性的典型违背。
3.不验证训练数据集中的重复项
通常，我们会被非常高精度的数字所激动。仔细检查通常会发现测试集中的许多示例都是训练集中示例的副本。在这种情况下，模型一般化的度量是不确定的(或无意义的)。一个相关的方面是训练集的随机化——如果没有随机化，我们可能会以训练中的所有秋季数据和测试中的夏季数据结束。这可能导致需要不必要的调试的丢失时期图。
4. 不验证固有数据集偏差:
从统计学的角度来看，数据集并没有捕捉到最终的真相。他们只捕获应用程序所有者当时为他们的用例所需要的属性。分析数据集的偏差和丢失数据非常重要。理解数据集的背景是至关重要的。数据集通常有一个或多个错误模式。如果这些误差是随机的，那么它们对模型训练的危害较小。但是，如果有一个 bug，比如某一行或某一列被系统地遗漏了，那么就会导致数据集中的偏差。例如，Andriod 用户的用户点击的设备细节由于一个错误而丢失，数据集将偏向 iPhone 用户活动。
5. 没有验证输入数据的单元测试
在传统的软件开发项目中，编写单元测试来验证代码依赖是一种最佳实践。在 ML 项目中，需要应用类似的最佳实践来连续测试、验证和监控所有的输入数据集。这包括确保测试集产生有统计意义的结果，并代表整个数据集。
6.关于数据属性含义的不正确假设
数据属性通常不会被归档。在大数据时代之前，数据在添加到中央数据仓库之前是经过筛选的。这被称为写模式。如今，数据湖的方法是首先聚合数据，然后推断数据在消费时的意义。这就是所谓的https://medium.com/wrong-ml/schema-on-read-curse-of-data-lakes-our-5-antidotes-1386199d262f**。一个相关问题是给定业务指标存在多个定义，即缺乏业务指标标准化。即使是最简单的指标，也可能有多种来源的事实和业务定义。例如,“新客户数量”这样的基本指标可以有不同的定义，这取决于它是由销售、财务、市场营销还是客户支持团队计算的。
7。数据源处不协调的变化
源处的模式更改通常与下游处理团队不协调。变化范围从模式变化(破坏现有管道)到难以检测的数据属性的语义变化(当您的模型出乎意料地开始变得疯狂时，情况会非常糟糕！).此外，当业务度量发生变化时，缺少定义的版本控制。
8.使用非代表性数据
数据有截止日期。10 年前的客户行为记录可能不具有代表性。此外，确保模型训练的数据是 IID (独立同分布)，并考虑数据的季节性。此外，数据集也在不断发展。数据分布的分析不是仅在模型创建时需要的一次性活动。相反，需要持续监控数据集的漂移，尤其是对于在线培训。通常，考虑到数据的孤岛性质，不同的数据集由不同的团队管理和编目。大量的部落知识被用来定位数据集。如果没有适当的尽职调查，团队会匆忙使用第一个可用的数据集。他们经常犯一个经典的错误，即假设所有数据集都同样可靠。它们中的一些由源团队非常紧密地更新和管理，而其他数据集被放弃或不定期更新或具有不稳定的 ETL 管道。
9。大型数据集内的任意样本选择**
给定非常大的数据集，采样通常是任意的。通常，团队要么决定使用所有的数据来训练 。 虽然更多的数据有助于建立准确的模型，但有时数据非常庞大，有数十亿条记录。在更大的数据集上进行训练需要时间和资源。每个训练迭代花费更长的时间，减慢了整个项目的完成。需要有效地使用数据采样。特别注意利用技术，例如重要性抽样。
总之，请确保在数据集选择中包含此清单。虽然这些步骤增加了工作量，并可能在开始时减慢速度，但它们在 ML 生命周期的后期会为自己付出很多倍的代价！
为了保护本博客中列出的人工智能缺陷， 请跟随 获取即将到来的博客“人工智能清单”的通知管理数据+人工智能在生产中的策略，检验 解开数据
9 台用于数学、Python 和数据科学的 Discord 服务器，您需要立即加入
联系、学习和获得灵感。
亚历山大·沙托夫在 Unsplash 上拍摄的照片
本月早些时候，我给写了一篇关于拥有一个社区在你的数据科学学习之旅中支持和激励你的重要性的文章。在那篇文章中，我分享了 Slack Workspaces，您可以加入它来与社区取得联系，并获得完成学习过程所需的所有支持。
虽然 Slack 是一个很好的与他人进行专业联系的选择，但我分享的一些工作空间需要一个教育或专业的电子邮件地址，我意识到这对每个人来说都不是一个可行的选择。即使你不是学生或教育机构的员工，你仍然值得拥有一个社区来支持和激励你的旅程。
除了在学术领域更受欢迎的 Slack 之外，还有一种沟通渠道一直受到各种各样的游戏玩家和程序员的欢迎。这个沟通渠道是不和谐的。
</6-data-science-slack-workshops-you-need-to-join-b0c00952105d>
与我之前的文章不同，在这篇文章中，我将与您分享 9 个关于数据科学不同方面的 Discord 服务器，从基础数学到 Python 编程，再到机器学习和人工智能等更核心的数据科学概念。
加入这些服务器将使您能够学习、分享您的经验，并建立一个网络来帮助您推进您在数据科学领域的职业生涯。
第一名:数学
当您开始数据科学学习之旅时，最基本的步骤之一是获得对数学的坚实理解。特别是学习代数、离散数学和概率论。数学也是一些人最初决定不进入数据科学的原因。但是，如果你有足够的支持，数学可以很容易理解。
这个列表中的第一个不和谐服务器是一个纯粹的数学服务器。这个服务器有超过 43000 名成员，他们总是参与致力于数学不同分支的各种渠道。这个 Discord 服务器涵盖了超出您进入数据科学所需的内容，但您可以将注意力和交流集中在几个渠道上，例如:#prealg-algebra、#linear-algebra、#computing-software和#probability-statistics。
№2:代码::一起
如果我们认为数据是讲故事的人，模式和趋势是我们的最终目标，那么编程就是从故事到最终目标的方法。您可以使用各种编程语言来开发自己的数据科学项目。
然而，当我们谈论数据科学时，Python 和 r 这两种编程语言总是脱颖而出。但是，您可以使用任何语言学习编程的基础知识，并将这些知识应用于任何语言。 Code::Together 是一个与编程相关的 Discord 服务器。从学习不同的语言到熟悉数据库和版本控制，以及寻找软件开发工作。
</9-comprehensive-cheat-sheets-for-data-science-46005d72b485>
№3:微软-python
假设你想学习一般的编程知识，也许试着感受一下不同编程语言对 Code::together Discord 的影响。但是，如果你只想专注于 Python，那么这个——以及下一个——Discord 服务器就是为你准备的。 Microsoft-python 是微软支持的服务器，讨论 python 的各个方面。
该服务器包括各种关注点不同的渠道，从使用 Python 的虚拟实验室到使用 Python 的物联网、Postgress DB 和 VSCode。Discord 还包括一个专门学习和开发 Python 数据科学项目的频道。
第四名:Python
Microsoft-python 服务器有一些与 python 相关的一般主题，但它更关注 Microsoft 支持的 Python 方面或 Microsoft 开发的工具。如果你想为 Python 的一切尝试一个更通用的 Discord 服务器，无论是学习它，使用它进行数据科学、安全或游戏开发，那么 Python Discord 服务器是一个不错的选择。
Python Discord 服务器是这个列表中最大的服务器之一，拥有超过 185，000 个成员。所以，不管你在哪个时区，你都可以保证至少有几千名会员在线帮助你。
№5:数据版本控制
当我学习软件开发的基础知识时，版本控制可能是最需要努力的技能。如果你试图寻找一个使版本控制变得轻而易举的解决方案，特别是对于数据科学，那么你一定遇到过数据版本控制 (DVC)工具。
DVC 工具是一个版本控制工具，可以保持你所有的项目文件与 Git 同步，并支持各种存储应用。该工具有自己的 Discord 服务器，讨论该工具的使用和数据科学的版本控制主题。
</6-machine-learning-certificates-to-pursue-in-2021-2070e024ae9d>
№6:r/数据非常有用
如果你问我最喜欢数据科学的哪一部分，毫无疑问，我会说是可视化。数据可视化是一种艺术形式；选择正确的可视化可以决定您的数据科学项目的成败。如果你能简单有效地交流你的发现，那么你就成功地讲述了你的数据故事。
r/DataIsBeautiful 是一个 subreddit Discord 服务器，讨论如何利用可视化来有效地交流数据。这个子编辑是拥有超过 1700 万会员的热门话题之一。所以，如果你想讨论可视化，没有比这更好的地方了。
№7:人工智能
数据科学是一个广阔的领域；术语数据科学用于描述任何包括与数据交互的技术。人工智能是数据科学的热门分支之一。
人工智能是许多伟大技术背后的核心技术，像自动翻译机、自动驾驶汽车和虚拟辅助。人工智能 Discord 服务器是一个讨论所有与人工智能相关的话题以及你需要了解该领域现状的地方。
№8:数据科学/ML/AI
接下来是 DS/ML/AI Discord 服务器。这个服务器是一个罕见的新服务器，有 1700 多个成员。有时候大型的 Discord 服务器是可以去的地方，但是小型的服务器通常有更具体的对话。
这个 Discord 服务器提供了许多活动，包括每周 Kaggle 协作和挑战，讨论最近的数据科学相关论文，并为专业人士和研究人员提供了讨论特定主题的私人房间。
</7-tips-for-data-science-newbies-d95d979add54>
№9:数据科学
最后但同样重要的是数据科学 Discord 服务器——讨论数据科学话题、最新趋势和研究进展的另一个好选择。
这个不和谐服务器的组织者试图将一些渠道活动整合在一起，如阅读小组、Kaggle 竞赛、每周视频演示等等。
最后的想法
独自学习之旅中最困难的一个方面就是独自学习。你感到孤立、孤独，在你前进的道路上需要支持。我可以说，去学校或训练营开始职业生涯的最好部分是你遇到的人，以及你从他们的经历中学到了多少，而不是从书本和讲座中学到的。
幸运的是，你不需要花很多钱去结识朋友和建立一个支持社区。技术通过创建在线社区来帮助我们，这些社区允许来自世界各地的人们分享经验、学习和共同成长。
在这些在线社区中，尤其是 Discord，在游戏和编程社区中一直为人所知和使用。这就是为什么在这篇文章中，我与您分享了 9 台 Discord 服务器，您今天可以加入这些服务器，找到您继续数据科学之旅并实现所有目标所需的支持和鼓励。
数据科学中的 9 种距离度量
常见距离测量的优点和缺陷
距离测量。图片由作者提供。
许多算法，无论是有监督的还是无监督的，都利用了距离度量。这些度量，例如欧几里德距离或余弦相似性，经常可以在诸如 k-NN、UMAP、HDBSCAN 等算法中找到。
理解距离测量领域比你可能意识到的更重要。以 k-NN 为例，这是一种经常用于监督学习的技术。默认情况下，它通常使用欧几里德距离。就其本身而言，这是一个很好的距离度量。
但是，如果您的数据是高度多维的呢？欧几里德距离还有效吗？或者，如果您的数据包含地理空间信息呢？也许哈弗线距离会是一个更好的选择！
知道何时使用哪种距离度量可以帮助你从一个差的分类器到一个精确的模型。
在本文中，我们将介绍许多距离测量方法，并探讨如何以及何时最好地使用它们。最重要的是，我将谈论它们的缺点，这样你就能认识到什么时候应该避开某些措施。
注意:对于大多数距离测量来说，关于它们的用例、优点和缺点，可以而且已经写了很长的详细论文。我会尽可能多地覆盖，但可能会功亏一篑！因此，请将本文视为这些措施的全球概述。
1.欧几里得距离
欧几里德距离。图片由作者提供。
我们从最常见的距离度量开始，即欧几里德距离。它是一种距离度量，最好解释为连接两点的线段的长度。
该公式相当简单，因为距离是使用勾股定理从点的笛卡尔坐标计算的。
欧几里得距离
缺点
虽然欧氏距离是一种常用的距离度量，但它并不随比例变化，这意味着根据要素的单位，计算的距离可能会有偏差。通常，在使用这种距离测量之前，需要将数据标准化。
此外，随着数据维数的增加，欧几里德距离变得越来越无用。这与维数灾难有关，维数灾难与高维空间不像我们从 2 维或 3 维空间中直观地预期的那样活动的概念有关。一个好的总结，见这篇帖子。
用例
当您有低维数据并且向量的大小对于测量很重要时，欧几里德距离非常有用。如果对低维数据使用欧几里德距离，kNN 和 hdb 等方法可以显示出很好的现成结果。
尽管已经开发了许多其他度量来解决欧几里德距离的缺点，但是它仍然是最常用的距离度量之一，这是有充分理由的。它使用起来非常直观，实现起来非常简单，并且在许多使用案例中显示了很好的效果。
2.余弦相似性
余弦距离。图片由作者提供。
余弦相似性经常被用作抵消高维欧氏距离问题的一种方法。余弦相似度就是两个向量之间夹角的余弦。如果两个向量都归一化为长度为 1，那么它也有相同的向量内积。
方向完全相同的两个向量的余弦相似度为 1，而方向相反的两个向量的相似度为-1。请注意，它们的大小并不重要，因为这是方向的度量。
余弦相似性
不足之处
余弦相似性的一个主要缺点是不考虑向量的大小，只考虑它们的方向。实际上，这意味着价值观的差异没有得到充分考虑。以推荐系统为例，余弦相似度没有考虑不同用户之间的评分差异。
用例
当我们有高维数据并且向量的大小不重要时，我们经常使用余弦相似度。对于文本分析，当数据用字数表示时，这种方法非常常用。例如，当一个单词在一个文档中比在另一个文档中出现得更频繁时，这并不一定意味着一个文档与该单词更相关。可能的情况是，文档的长度不均匀，计数的大小不太重要。那么，我们最好使用余弦相似度，它不考虑大小。
3.汉娩距
汉明距离。图片由作者提供。
汉明距离是两个向量之间不同值的数量。它通常用于比较两个长度相等的二进制字符串。它还可以用于字符串，通过计算彼此不同的字符数来比较它们彼此的相似程度。
不足之处
如你所料，当两个向量不等长时，汉明距离很难使用。你可能想要比较相同长度的向量，以了解哪些位置不匹配。
此外，只要它们不同或相等，它就不考虑实际值。因此，当震级是一个重要的度量时，不建议使用此距离度量。
用例
典型的使用案例包括数据通过计算机网络传输时的错误纠正/检测。它可以用来确定二进制字中失真比特的数量，作为一种估计误差的方法。
此外，您还可以使用海明距离来度量分类变量之间的距离。
4.曼哈顿距离
曼哈顿距离。图片由作者提供。
曼哈顿距离，通常称为出租车距离或城市街区距离，计算实值向量之间的距离。想象一下在一个统一的网格(如棋盘)上描述物体的向量。曼哈顿距离是指两个向量之间的距离，如果它们只能移动直角的话。在计算距离时不涉及对角线移动。
曼哈顿距离
不足之处
尽管曼哈顿距离似乎对高维数据很有效，但它比欧几里得距离更不直观，尤其是在高维数据中使用时。
此外，它更有可能给出比欧几里德距离更高的距离值，因为它不是可能的最短路径。这不一定会产生问题，但你应该考虑到这一点。
用例
当数据集具有离散和/或二进制属性时，Manhattan 似乎工作得很好，因为它考虑了在这些属性值内实际可以采用的路径。以欧几里德距离为例，将在两个向量之间创建一条直线，而实际上这可能实际上是不可能。
5.切比雪夫距离
切比雪夫距离。图片由作者提供。
切比雪夫距离被定义为沿任意坐标维度的两个向量之间的最大差值。换句话说，它就是沿一个轴的最大距离。由于其性质，它通常被称为棋盘距离，因为国王从一个方格到另一个方格所需的最小移动次数等于切比雪夫距离。
切比雪夫距离
不足之处
切比雪夫通常用于非常特定的用例，这使得它很难用作通用的距离度量，如欧几里德距离或余弦相似性。因此，建议只在你完全确定它适合你的用例时才使用它。
用例
如前所述，切比雪夫距离可用于提取从一个方块到另一个方块所需的最少移动次数。此外，在允许无限制 8 向移动的游戏中，它可以是一个有用的措施。
在实践中，切比雪夫距离经常用于仓库物流，因为它非常类似于高架起重机移动物体所需的时间。
6.闵科夫斯基
闵可夫斯基距离。图片由作者提供。
闵可夫斯基距离是一个比大多数更复杂的度量。它是在赋范向量空间(n 维实空间)中使用的度量，这意味着它可以在距离可以表示为具有长度的向量的空间中使用。
这项措施有三个要求:
- 零向量 —零向量的长度为零，而其他向量的长度为正。例如，如果我们从一个地方旅行到另一个地方，那么距离总是正的。然而，如果我们从一个地方旅行到它自己，那么距离是零。
- 标量因子 —当你将向量乘以一个正数时，它的长度会改变，同时保持它的方向。例如，如果我们在一个方向上走了一定的距离，加上相同的距离，方向不变。
- 三角形不等式 —两点间最短的距离是一条直线。
闵可夫斯基距离的公式如下所示:
闵可夫斯基距离
关于这个距离度量最有趣的是参数**p**的使用。我们可以使用这个参数来操纵距离度量，使其与其他度量非常相似。
p的常用值有:
- p=1 —曼哈顿距离
- p=2 —欧几里德距离
- p= ∞ —切比雪夫距离
不足之处
Minkowski 与它们所代表的距离度量具有相同的缺点，因此很好地理解像曼哈顿、欧几里德和切比雪夫距离这样的度量是极其重要的。
此外，参数p实际上很难处理，因为根据您的使用情况，找到正确的值在计算上是相当低效的。
用例
p的好处是可以迭代它，找到最适合您的用例的距离度量。它允许您在距离度量上有很大的灵活性，如果您非常熟悉p和许多距离度量，这将是一个巨大的好处。
7.Jaccard 索引
Jaccard 索引。图片由作者提供。
Jaccard 指数(或交集/并集)是一种用于计算样本集相似性和多样性的指标。它是交集的大小除以样本集的并集的大小。
实际上，它是集合之间相似实体的总数除以实体的总数。例如，如果两个集合共有 1 个实体，总共有 5 个不同的实体，那么 Jaccard 索引将是 1/5 = 0.2。
为了计算 Jaccard 距离，我们只需从 1 中减去 Jaccard 索引:
雅克卡距离
不足之处
Jaccard 索引的一个主要缺点是它受数据大小的影响很大。大型数据集对索引有很大的影响，因为它可以显著增加并集，同时保持交集相似。
使用案例
Jaccard 索引通常用于使用二进制或二进制数据的应用程序中。当你有一个深度学习模型预测图像的片段时，例如，一辆汽车，Jaccard 指数可以用来计算预测的片段给出真实标签的准确性。
类似地，它可以用于文本相似性分析，以测量文档之间有多少单词选择重叠。因此，它可用于比较多组模式。
8.半正矢
哈弗森距离。图片由作者提供。
哈弗线距离是给定经度和纬度的球体上两点之间的距离。它非常类似于欧几里得距离，因为它计算两点之间的最短直线。主要区别在于不可能有直线，因为这里假设两点在一个球面上。
两点间的哈弗线距离
不足之处
这种距离测量的一个缺点是，它假设这些点位于一个球上。实际上，这种情况很少发生，例如，地球不是完美的圆形，这在某些情况下会使计算变得困难。取而代之的是，看向假定为椭球面的万有引力距离会很有趣。
用例
正如你可能已经预料到的，哈弗线距离经常用于导航。例如，当你在两个国家之间飞行时，你可以用它来计算两国之间的距离。请注意，如果距离本身已经不是很大，那么它就不太适合。曲率不会有那么大的影响。
9.索伦森-戴斯指数
索伦森-骰子系数。图片由作者提供。
s rensen-Dice 指数与 Jaccard 指数非常相似，因为它衡量样本集的相似性和多样性。虽然它们的计算方式相似，但索伦森-戴斯指数更直观一些，因为它可以被视为两个集合之间的重叠百分比，该值介于 0 和 1 之间:
索伦森-骰子系数
不足之处
就像 Jaccard 指数一样，它们都夸大了集合的重要性，而这些集合很少或根本没有真实的正集合。因此，它可能会主导多组的平均分数。它对每个项目的权重与相关集合的大小成反比，而不是一视同仁。
用例
用例与 Jaccard index 相似(如果不是相同的话)。你会发现它通常用于图像分割任务或文本相似性分析。
注意:除了这里提到的 9 种，还有更多的距离度量。如果你正在寻找更有趣的指标，我建议你看看下面的一个:Mahalanobis、堪培拉、Braycurtis 和 KL-divergence。
感谢您的阅读！
如果你像我一样，对人工智能、数据科学或心理学充满热情，请随时在 LinkedIn 上添加我，或者在 Twitter 上关注我。
制作精美图表的 9 个简单步骤
如何用经过优雅重组的图表在演示幻灯片中讲述激动人心的故事
图片作者作者
我是一名分析师。我主要使用图表——用于演示的图表，仪表板上的图表，等等。然而，我看到的大多数图表都是为了在客户眼中看起来漂亮而过度使用的。事实是，他们发现很难理解他们。
有用的图表简单但不乏味。它只讲述了一个故事，而且做得很好。它不言自明，只需要很少的思考就能理解。此外，这样的图表使用每个人都能看到的令人愉快的颜色。
这篇文章是实用指南。我们将通过一个混乱的条形图，使它变得优雅。这里的重点是演示图表。然而，这些原则中的大部分对于仪表板也是有用的。
我们的平均注意力持续时间是 8 秒。这就是我们的目标——在八秒钟内提出想法。
背景资料
我使用这个簇状柱形图来解释这些步骤。它比较了许多地区 2020 年和 2019 年的电视销售。这里使用的数据是不真实的，仅用于说明目的。
图片作者
当然，它看起来很漂亮。我也喜欢深色背景。然而，演示文稿中图表的目的不是炫耀演示者的技能或愿望。它需要优化，以便更好地阅读。
在这个图表中，读者需要自己找出这个故事。我可以看到亚洲的销售额下降了大约 100 万美元，尽管在美国却猛增了 100 万美元。但另一个人可能会关注非洲和欧洲，那里的销售保持不变。如果你要讨论的信息是前一个，那么另一个就会造成混乱。更不用说，你的观众可能会有许多不同的解读方式。
让我们一步一步地开始清理。
1.比起 3D，更喜欢 2D 图形
我同意 3D 图形很美。但是我们知道更远的物体看起来比它们实际上要小。在很多情况下，它会导致一个错误的解读。
我在很多仪表盘上都见过这种情况，因为这个简单的调整让图表更有吸引力。然而，大多数数据可视化专家会同意不应该使用 3D。
图片作者
2.使用白色背景
出于许多原因，白色背景是首选。首先，它与所有其他颜色形成鲜明对比。白色和灰色很相配，而黑色和灰色就不相配。
第二，白色背景在印刷和数字媒体上都很好用。
图片作者
3.为自然的眼球运动组织内容
我们的眼睛从左到右扫描图表，然后从上到下。因此，将关键元素放在左上角。我从左对齐的标题开始，然后是图例，然后是主图表。
标称数据用横条图，序数数据用柱形图比较好。例如，如果我们创建多年的图表，最好使用柱形图。在这种情况下，当我们跨地区比较数据时，水平条是一个很好的拟合。
除了让图表水平，我还让它按 2020 年的销售数字排序。这使得图表易于理解。
图片作者
4.标签比网格线和坐标轴更好
网格线和轴有助于精确测量。他们可以在探险中提供帮助。但是在演示中，观众永远不会使用它们。如果你的读者不打算用网格线和坐标轴来阅读数据，那就去掉它们。更少的细节让图表更干净。
我喜欢标签，因为它们更接近数据点，也更容易理解。
图片作者
5.使用令人愉快的颜色
为演示文稿选择正确的颜色是一件棘手的事情。有冷色，也有暖色。有些人看不到所有的颜色。
大约 12 个男人中有一个，200 个女人中有一个不能看到所有的颜色。在不同的类型中，红绿色盲是最常见的一种。因此，出于可访问性的原因，最好避免使用这些颜色。
蓝色和橙色的组合在大多数情况下都有效。蓝色可以用来突出某物。因为蓝色是冷色，所以人们可以盯着它看更久。相反，我们可以使用暖色的橙色，来立即吸引注意力。其他元素我都用灰色，因为它不会争夺注意力。
图片作者作者
6.使用视觉层次突出故事
我们将元素放在自然的眼球运动上，并且在设计中使用了令人愉悦的颜色。我们还可以使用其他的视觉层次技术。
大小和接近度
大小是设置图表元素可见性的有效方式。我们将所有的轴标签和数据标签做得更小，因为它们对故事没有直接贡献。
同样，邻近有助于用图表元素创建逻辑组。我们使两个条形之间的间隙比任何条形的宽度都要窄。我们还使两个数据点(区域)之间的间隙比同一个数据点中两个条形之间的间隙更宽。
字体和排版
无衬线字体在演示图表上清晰可见。衬线字体适用于像段落这样的大文本。我最喜欢的图表是 Calibri。
此外，轻字体有助于不分散读者的注意力。
图片作者作者
7.使用辅助元素来吸引读者的注意力
辅助元素是按顺序吸引读者注意力的地标。
我们这个例子的故事是亚洲的下降和美洲的增长。我用的橙色标签更接近亚洲的 2020 酒吧。橙色很快引起注意，也告诉读者有一些奇怪的事情。
我还使用了一个靠近美洲 2020 条形图的蓝色标签来告诉读者美国销售额的增长。
图片作者作者
8.描述性标题、副标题和描述
在图表上少用文字。然而，他们是一个很好的方式来告诉你的信息，并直接消除任何困惑。
我将标题和可选的副标题放在图表的左上角。因为我不想让这些元素立即引起注意，所以我使用灰色字体，并把重要的部分加粗。
我在图表底部用小字体写下了所有的描述。他们在传达我的故事中没有起到任何主要作用。因此，它应该被削弱。
图片由作者
这个版本比我们最初的版本更容易阅读。我们的注意力立刻转向橙色的 2M 标签。这表明亚洲出了问题。然后，我们转向+100 万的标签，并认为，“美国做得很好。”
由于不再有吸引注意力的元素，我们回到左上角进行自然的眼球运动。标题说明了这张图表的内容——2020 年的电视销售。
标题后面的图例告诉我们，蓝色条是 2020 年的销售额。现在一切都开始有意义了。底部的附加注释解释了原因、来源等。
9.演示前测试
无论你多么努力地简化事情，都有可能没有正确传达信息。因此，把你的作品展示给与你的观众有相似特征的人总是好的。
我通常让几个同事看着图表讲一个故事。大多数人都能想出我想要传达的故事。通常需要大约 10-15 秒。仍然高于 8 秒的目标。如果他们花了更长时间或者根本想不出一个故事，我就重写。
结论
我们到处使用图表来讲述我们的故事。但通常，我们认为它们是辅助材料，而它们可以扮演更重要的角色。
一个伟大的图表会自己讲述这个故事，而演示者的角色是支持性的。
在本文中，我们已经看到了许多清理和组织图表的方法，可以快速抓住读者的注意力，并引导他们浏览整个故事:
- 我们用的是 2D 图表，而不是 3D 图表；
- 喜欢白色背景而不是黑色背景；
- 利用从左到右和从上到下的自然眼球运动；
- 删除多余的元素，如网格、轴，并在其位置使用数据标签；
- 大部分使用灰度，用蓝色突出，用橙色获得即时关注；
- 利用视觉层次属性，如大小、接近度、字体和排版；
- 使用支持元素来驱动焦点；
- 使用描述性的标题、副标题和描述。
最后，我们承认，在向观众推销之前，对真实的人进行测试对于一个有用的图表是至关重要的。
这篇文章主要适用于演示幻灯片上的图表。如果是在仪表板上或用于数据探索的图表上，方法可能会有所不同。然而，有些概念仍然可以在这些情况下使用。
**Further reading**1\. [Story Telling With Data Blog](http://www.storytellingwithdata.com/blog)
2\. [The Ultimate Guide to Visual Hierarchy](https://www.canva.com/learn/visual-hierarchy/)
3\. [Data Visualization Accessibility](/data-visualization-and-accessibility-three-recommended-reads-and-top-tips-9c5e862b464e)
掌握 Seaborn 网格的 9 个示例
面网格和对网格实用指南
马库斯·斯皮斯克在 Unsplash 上的照片
数据可视化是数据分析的一个基本部分。它帮助我们更好地理解数据中的关系，并探索底层结构。
我们可以通过在同一个图中组合多个图来创建更多的信息可视化。有许多方法可以创建多图可视化。Seaborn 库使得使用 FacetGrid 和 PairGrid 类生成这样的图变得简单明了。
在本文中，我们将通过 9 个例子来练习如何使用这些函数。我们将从非常基础的开始，逐步增加复杂性。例如，我们将使用 Kaggle 上的客户流失数据集。
我们从导入必要的库开始。
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
sns.set(style='darkgrid')
下一步是将数据集读入熊猫数据帧。
cols = [
'Attrition_Flag','Gender','Education_Level',
'Marital_Status','Customer_Age','Credit_Limit',
'Total_Trans_Amt','Avg_Open_To_Buy'
]churn = pd.read_csv(
"/content/BankChurners.csv", usecols=cols
).sample(n=1000)churn = churn[churn.Marital_Status.isin(['Married','Single'])]churn = churn[churn.Education_Level.isin(['Graduate','High School', 'Unknown'])]churn.head()
(图片由作者提供)
我已经选择了原始数据集中的一些列，还做了一些过滤和采样，以便进行演示。
FacetGrid 是一个子情节网格，允许将数据集的结构转移到子情节。Row、col 和 hue 参数可以看作是 FacetGrid 对象的三个维度。
我们首先创建一个 FacetGrid 对象，然后映射数据。让我们从一个非常简单的创建 FacetGrid 结构的例子开始。
示例 1
g = sns.FacetGrid(churn, col='Attrition_Flag', height=4, aspect=1.2)
(图片由作者提供)
我们现在有一个仅代表结构的空图。Seaborn 根据传递给 col 和 row 参数的列中的值生成结构。由于损耗标志列有两个唯一值，因此返回一个包含两列的网格。
高度和纵横比参数调整支线剧情的大小。
示例 2
一旦我们有了 FacetGrid 对象，我们就可以将数据映射到它。
g = sns.FacetGrid(churn, col='Attrition_Flag', height=4, aspect=1.2)g.map(sns.histplot, 'Customer_Age')
(图片由作者提供)
map 方法将绘图函数和要绘图的变量作为参数。上面的网格使用直方图显示了客户年龄列的分布。数据点根据损耗标志列中的类别进行分隔。
示例 3
传递给 map 方法的绘图函数不必是 Seaborn 函数。我们也可以使用 matplotlib 函数。例如，上面的图可以用“plt.hist”创建。
g = sns.FacetGrid(churn, col='Attrition_Flag', height=4, aspect=1.2)g.map(plt.hist, 'Customer_Age')
(图片由作者提供)
注意 : Seaborn 也接受自定义函数用于映射。但是，在创建它们时，您必须遵循某些规则。
实例 4
到目前为止，我们只使用了 col 参数。我们可以使用行和色调参数来添加更多的维度。
g = sns.FacetGrid(
churn, row='Attrition_Flag', col='Gender', hue='Marital_Status',
height=4, aspect=1.4
)g.map(sns.scatterplot, 'Total_Trans_Amt', 'Avg_Open_To_Buy')g.add_legend()
(图片由作者提供)
我们有一个散点图网格，显示两个数字列之间的关系。我们能够在流失标记、性别和婚姻状况列中分别展示类别之间的关系。
当我们使用 hue 参数时，也应该使用 add_legend 函数添加图例。
实例 5
我们可以指定支线剧情所代表的类别的顺序。row_order 和 col_order 参数可用于排序。
col_order = churn.Education_Level.value_counts().indexg = sns.FacetGrid(
churn, col='Education_Level', height=4,
col_order = col_order
)g.map(sns.histplot, 'Total_Trans_Amt')
(图片由作者提供)
您还可以从图中注意到，类别是按大小排序的。我们已经使用 Pandas 的 value_counts 函数为类别生成了一个订单。
实例 6
PairGrid 生成一个图形网格，显示变量的成对关系。例如，我们可以创建一些数值变量之间的散点图网格。
cols = ['Credit_Limit','Total_Trans_Amt','Customer_Age']g = sns.PairGrid(churn[cols], height=3.5)g.map(sns.scatterplot)
(图片由作者提供)
例 7
在前面的例子中，对角线上的图没有用，因为它们显示的是变量本身的散点图。为了使网格提供更多信息，我们可以在对角线上绘制变量直方图。
我们通过使用 map_diag 和 map_offdiag 方法传递不同的函数。
g = sns.PairGrid(churn[cols], height=3)g.map_diag(sns.histplot)g.map_offdiag(sns.scatterplot)
(图片由作者提供)
这比前一个更好，因为我们还得到了每个变量的分布概况。
实施例 8
PairGrid 还支持 hue 参数，因此我们可以基于分类变量来分离散点图中的数据点。
另一个有用的参数是 var 参数。在前面的 PairGrid 示例中，我们使用了 dataframe 的一个子集，因此它只包含要绘制的列。我们还可以向 var 参数传递要绘制的列的列表。
g = sns.PairGrid(churn, vars=cols, hue='Attrition_Flag', height=3)g.map_diag(sns.histplot)g.map_offdiag(sns.scatterplot)g.add_legend()
(图片由作者提供)
示例 9
在 PairGrid 中，对角线上下侧的图是镜像。因此，从不同的角度来看，我们有相同的情节。
我们可以选择在对角线的上侧和下侧绘制不同类型的图。map_upper 和 map_lower 函数用于为上边和下边生成不同种类的图。
g = sns.PairGrid(churn, vars=cols, height=3)g.map_diag(sns.histplot)g.map_upper(sns.scatterplot)g.map_lower(sns.histplot)
(图片由作者提供)
上方是散点图。对角线包含每个变量的直方图。在下方，我们有二维直方图。
结论
我们已经练习了如何使用 Seaborn 的 FacetGrid 和 PairGrid 创建多绘图可视化。它们是探索性数据分析的非常有用的工具。Seaborn 生成这些图的方式使它们简单易懂。
理解 FacetGrid 和 PairGrid 之间的区别很重要。在 FacetGrid 中，每个子情节代表相同的关系，但条件不同。例如，我们可以在 FacetGrid 中有两个变量的散点图，并根据另一个变量的类别来分离数据点。
在 PairGrid 中，每个图显示不同的关系。例如，当我们创建一个包含三个变量的散点图对网格时，每个子图代表一个不同的成对关系。
为了丰富功能和外观，可以在 FacetGrid 和 PairGrid 对象上添加更多的特性。一旦你熟悉了基本的，你就可以创建更详细的网格了。
感谢您的阅读。如果您有任何反馈，请告诉我。
9 个免费的优质资源来学习和拓展您的 Python 技能
不管你的技术背景如何，都要学习 Python。
如果你是科技领域的新手，更确切地说是编程界的新手，那么你一定已经得到了建议，对你来说最好的语言之一是 Python。但是，即使你懂一门编程语言，Python 的应用也很广泛；你一定和它有过交集，或者为了一个项目学过它。
Python 成为当今流行的编程语言有很多原因；它比其他语言更容易学习，用途非常广泛，可以用于许多不同的应用程序，并且它有一个庞大的社区来支持新手或任何希望扩展其当前 Python 知识的人。
作为一名 Python 教师，我总是告诉我的学生，尽管 Python 是一门相对容易学习的语言，但要掌握它并不容易。因此，编写干净、有效的 Python 代码需要坚实的知识基础和大量的实践。幸运的是，如果你真的想提高你的 Python 技能，或者如果你是新手，开始构建它，互联网上有很多你可以使用的资料。
Python 材料的数量令人震惊，有数百本书、网站和博客。成千上万的教程、开发者和 YouYube 视频。虽然我很感激这种巨大的努力，但我知道如果你是这个领域的新手，或者只是为了提高自己而寻找一般信息，在一大堆材料中导航是多么困难。
在这篇文章中，我收集了 9 个免费资源，你可以用它们来学习、提高或扩展你的知识和技能。因此，我将为初学 Python 的人提供大约 3 个参考资料，为已经了解一些 Python 但想扩展知识的人提供 3 个参考资料，还有 3 个参考资料涵盖更高级的主题和 Python 的应用。
让我们开始吧…
踮起脚尖(初学者)
№1: 100 页 Python 简介，作者 Sundeep Agarwal
让我们从一本面向绝对编程初学者的优秀书籍开始吧， 100 页 Python 简介。我最喜欢这本书的一点是它简明扼要。因此，它将在 100 页内为您提供开始使用 Python 的基本信息。
这本书涵盖了从安装 Python 到基本数据类型和控制流语句到函数、字符串操作和处理文件的基础知识。通读这本书后，你将拥有坚实的编程和 Python 基础。
№2:Python 的一个字节
另一本适合初学者的极好的书是 A Byte of Python ，它涵盖了从初级到中级的所有 Python 基础知识。这本免费的 HTML 书介绍了数据类型、变量、控制流语句、函数、调制等等。
它还涉及编程和 Python 中的问题解决过程，处理输入和输出操作以及面向对象编程的基础。
№3:Python 编程简介
我们列表中的第三个也是最后一个初学者资源是Python 编程入门网站。这个网站假设你没有任何编程知识，你正在开始你的 Python 之旅。这个资源的不同之处在于，它以可视化的方式接近编程的基础。
或者通过使用图形 Python 库 Turtle。如果你想通过画图形来学习 Python，或者如果你正在教孩子和年轻人编程，并且想让事情变得有趣，这个网站是非常好的。
</5-ways-to-write-more-pythonic-code-a33069f968c>
变得舒适(中级)
№4:Python 神奇方法指南
所以，你学会了基础知识；语法现在对你有意义了；您可以进行一些简单的编程，甚至解决一些中型问题。下一步是什么？一般来说，编程的一个中间的、基本的方面是面向对象编程(OOP)。尤其是 Python 中的魔法方法。
魔术函数是 Python 中 OOP 的核心，所以我会推荐你在学习完 Python 中 OOP 的最起码的基础之后，比如知道类的基本构造，你需要深入钻研魔术方法之后再进一步 OOP。这将有助于更好、更容易地理解更高级的 OOP 概念。
№5:超越 Python 的基本知识，作者 Al Sweigart
我最喜欢的科技作家之一是阿尔·斯威加特。用 Python 自动化枯燥的东西是我最喜欢的 Python 书籍之一。Al Sweigart 有一种奇妙的方式，以一种易于理解的方式传递和解释概念和主题。
除了 Python 的基本知识之外，还有其他基本知识，如代码风格，Python 中最常见的错误来源，什么是函数式编程，如何加快代码速度，理解计算复杂性和 Big-O，以及如何编写高效和信息丰富的文档字符串和注释。
№6:用 Python 构建技能，作者 Steven F. Lott
以下资源是一本免费的 500 多页的 PDF 书籍，几乎涵盖了 Python 的所有内容，从绝对入门到文件处理和打包。因此，如果你正在寻找一种资源来从头到尾学习用 Python 编写的构建技能，那么 Steven F. Lott 将是你的绝佳选择。
这本书可能是完整的 Python 书籍之一，从什么是 Python 到如何打包你的代码并在发布给公众后维护它。
</5-python-books-to-transfer-your-code-to-the-next-level-a5af0981e204> [## 5 本 Python 书籍，让你的代码更上一层楼
towardsdatascience.com](/5-python-books-to-transfer-your-code-to-the-next-level-a5af0981e204)
更深的潜水(高级)
№7:Python 中的干净架构
继续学习有经验的程序员，他们希望学习如何编写更好的、可读的代码，并使用 Python 构建应用程序和框架。我给这些人的第一个资源是 Python 中的清洁架构。这本书涵盖了用 Python 编写干净代码和构建可靠架构的主题。
这本书涵盖了系统架构的不同层次，以及如何有效地开发每一层。此外，它还讨论了构建和维护 API、构建 web 应用程序、错误管理和应用程序的 docker 映像。
№8:Harry PERC ival 和 Bob Gregory 的 Python 架构模式
学习完基础知识后，对于每个编程人员来说，知道如何编写更好、更整洁、更结构化的代码来阅读、理解和测试是一项基本技能。学习代码架构模式的一个很好的资源是我的下一本书，Python 的架构模式。
在本书中，您将了解开发人员在设计和编写代码时遵循的不同模式。它还涉及到测试的基础知识，这是软件开发周期中必不可少的步骤。
№9:全栈 Python
如果你懂一些编程，但一定是 Python，下面的资源非常适合你。全栈 Python 是一个很好的资源，可以教你 Python 的基础知识和用 Python 构建应用的高级知识。
这个网站经历了不同的开发环境，以及如何选择最适合你的一个；它涵盖了如何安装和使用它们。编程的一个关键方面是版本控制，我相信你应该在学习如何编码的同时学习，这个网站做得很好。
</6-best-python-ides-and-text-editors-for-data-science-applications-6986c4522e61> [## 数据科学应用的 6 个最佳 Python IDEs 和文本编辑器
towardsdatascience.com](/6-best-python-ides-and-text-editors-for-data-science-applications-6986c4522e61)
外卖食品
所以你想进入编程领域，或者你已经进入了编程领域，但是你想扩展你的知识或者发展和磨练你的技能。所以你前往谷歌，试图寻找 Python 相关的学习资料，点击搜索，数百万条结果出现。那太好了；信息的可用性是谷歌和互联网最好的方面之一。
但是，随着信息的可用性，另一个挑战出现了:代替寻找信息，你需要发展一种发现高质量信息的技能。那项技能需要大量的时间和努力。如果你需要学习一些东西，尤其是现在，技术正在以疯狂的速度发展，你会想要相对快速地学习这个概念。
在当今世界，快速获取高质量的信息是一项具有挑战性的任务。尤其是如果讨论的主题是非常流行的，比如数据科学、编程或 Python。因为我完全理解花几个小时寻找信息的挫败感，我总是喜欢帮助人们以最小的努力获得他们正在寻找的信息。
因为你应该把精力花在学习上，而不是去找资料学习，所以在这篇文章里，我提出了各种高质量的适合各个层次的 Python 学习资料。因此，无论您是编程新手、有一些经验，还是只想构建一些高级主题，您都会在这个列表中找到一定会让您受益的材料。
祝你好运。
掌握 Scikit 的 9 个指南——学而不中途放弃
学习适合我的方法
布拉登·科拉姆在 Unsplash 拍摄的照片
毫无疑问， Scikit-learn 是当今最好的机器学习库之一。这有几个原因。Scikit-learn 估值器之间的一致性是一个原因。你在任何其他机器学习库中都找不到这样的一致性。。fit()/。predict() 范式最好地描述了这种一致性。另一个原因是 Scikit-learn 有多种用途。它可以用于分类、回归、聚类、降维、异常检测。
因此，Scikit-learn 是您的数据科学工具包中必备的 Python 库。但是，学习使用 Scikit-learn 并不简单。事情没有你想象的那么简单。学之前你得设置一些背景。即使在学习 Scikit-learn 时，您也应该遵循一些指南和最佳实践。在这篇文章中，我很高兴分享 9 条指导方针，它们帮助我掌握了 Scikit-learn，而没有中途放弃学习过程。只要有可能，我将包含我以前帖子的链接，这将帮助您设置背景并继续学习 Scikit-learn。
设置背景
准则 1:在使用 Scikit-learn 进行 stat 之前，您应该熟悉 Numpy
Numpy 是一个强大的库，用于在 Python 中执行数值计算。Scikit-learn 和许多其他用于数据分析和机器学习的 Python 库都构建在 Numpy 之上。Scikit-learn 估计器的输入和输出是 Numpy 数组的形式。
数据科学和机器学习所需的数学知识中，大约 30–40%来自线性代数。矩阵运算在线性代数中起着重要的作用。我们经常使用 Numpy 在 Python 中进行矩阵运算。它也有矩阵运算的特殊类和子程序包。
从上面的事实来看，很明显你应该在 stat 使用 Scikit-learn 和机器学习之前熟悉 Numpy。我写的以下文章涵盖了 Numpy 主题，如 Numpy 基础知识、数组创建、数组索引、使用 Numpy 执行算术运算和线性代数。这些课程是专门为在学习 Numpy 相关主题时获得实践经验而设计的。
- 面向数据科学的 NumPy:第 1 部分— NumPy 基础知识和数组创建
- 用于数据科学的 NumPy:第 2 部分—数组索引和切片
- 数据科学的 NumPy:第三部分——NumPy 数组上的算术运算
- 用于数据科学的 NumPy:第 4 部分—带有 NumPy 的线性代数
- Numpy 中的 10 大矩阵运算及示例
准则 2:平行学习更有效率
一旦你熟悉了 Numpy，你就为 并行学习 做好了准备——一个可以用来同时学习几个 Python 包的学习过程。一旦你熟悉了 Numpy，你可以同时开始学习 Pandas，matplotlib 和 seaborn 包。下面我写的文章涵盖了熊猫、matplotlib、seaborn 相关的话题。
准则 3:建立你自己的编码环境
边学边练是在数据科学和机器学习领域取得成功的关键。电脑上最好有自己的编码环境。获得 Python 和其他数据科学库的最简单和最容易的方法是通过 Anaconda 安装它们。对于数据科学来说，这是最受欢迎的 Python 发行版。它包括所有的东西:数百个包，ide，包管理器，导航器等等。它还提供了安装新库的工具。您需要做的就是通过 Anaconda 终端运行相关的命令。要开始使用 Anaconda:
- 去 https://www.anaconda.com/products/individual
- 点击相关的下载选项
- 下载安装文件后，双击它并按照屏幕上的说明在本地机器上安装 Anaconda。安装时，请保持 Anaconda 推荐的默认设置。
注意:在撰写本文时，Python 3.8 for Windows(64 位和 32 位)、macOS 和 Linux 都提供了 Anaconda 安装程序。您可以根据您的电脑下载相关的安装程序。
安装后，您可以在桌面上找到图标。双击它启动蟒蛇导航器。大多数常用的包，比如 numpy、pandas、matplotlib、seaborn、scikit-learn 和更多的包都已经附带了 Anaconda。您不需要单独安装它们。从 Anaconda navigator 中，您可以启动 Jupyter 笔记本 IDE 来运行您自己的代码。
开始使用 Scikit-learn
准则 4:区分监督学习和非监督学习
监督学习
在监督学习中，我们使用标记为 的 数据来训练模型。 X 和 y 都参与了培训过程。 X 包括输入变量。 y 包括标签。在机器学习术语中， X 被称为特征矩阵(通常是二维 numpy 数组或 pandas DataFrame)，而 y 被称为目标向量(通常是一维 numpy 数组或 pandas 系列)。**
(图片由作者提供)
数学上，当我们有 X 和 y 时，我们用监督学习算法学习输入到输出的映射函数，y=f(x)。监督学习的目标是很好地确定映射函数，以便为新的未知数据找到标签(在分类的情况下)或值(在回归的情况下)。
分类和回归是监督学习的两种类型。你可以通过阅读下面我写的文章来学习分类和回归算法。他们都会给你实践经验。在用 Python 和 Scikit-learn 实现这些算法时，您可以了解这些算法在幕后是如何工作的。
- 带梯度下降的线性回归
- 支持向量机与 Scikit-learn
- 使用决策树训练回归模型
- 随机森林——决策树的集合
- 具有机器学习流水线的多项式回归
- 【XGBoost 之旅:里程碑 1——设置背景
- XGBoost 之旅:里程碑 2 —用 XGBoost 分类
- XGBoost 之旅:里程碑 3—XGBoost 回归
无监督学习
在无监督学习中，我们仅使用输入变量(X)来训练模型，而不使用标签(y)。
(图片由作者提供)
无监督学习的目标是在给定的输入数据中发现隐藏的模式或潜在的结构或异常值。
聚类、降维和异常(离群点)检测是无监督学习的三种类型。你可以通过阅读下面我写的文章来学习聚类、降维、异常检测算法。他们都会给你实践经验。在用 Python 和 Scikit-learn 实现这些算法时，您可以了解这些算法在幕后是如何工作的。
- 动手 K 均值聚类
- 2021 年你应该知道的 4 种有用的聚类方法
- 使用 Scikit 的主成分分析(PCA)-learn
- 用 R 和 Python 对乳腺癌数据进行主成分分析
- PCA 背后的统计和数学概念
- 用 R 和 Python 对“女子跟踪记录”数据进行因子分析
- 2021 年你应该知道的两种离群点检测技术
- 4 Python 中离群点检测的机器学习技术
准则 5:熟悉 sci kit-学习一致性
在 Scikit-learn 中，机器学习模型通常被称为估计器。有两种主要类型的估计器:预测器和变压器。预测器进一步分为分类器和回归器。
。fit()/。predict() 范例应用于预测器。。fit()/。trans inform()范例应用于变压器。例如:
from sklearn.linear_model import LinearRegressionlin_reg = LinearRegression()
lin_reg.fit(X_train, y_train)
predictions = lin_reg.predict(X_test)
当我们调用 lin_reg 的 fit() 方法时，模型开始从数据中学习(即寻找线性回归模型系数)。当我们调用 lin_reg 的 predict() 方法时，预测是在新的未见过的数据上进行的。这种。fit()/。predict() 一致性适用于所有 Scikit-learn 预测器。另外，注意导入 LinearRegression() 类时的一致性。该类位于 linear_model 子包中。这就是为什么我们调用" from sk learn . sub _ package _ name "后跟 "import class_name" 。当导入所有 Scikit-learn 预测器时，会应用这种一致性。
lin_reg 的属性可以通过带下划线符号 _ 的相关名称来访问。例如， lin_reg.coef_ 和 lin_reg.intercept_ 给出线性回归模型系数和截距。下划线符号是评估器属性的另一个 Scikit-learn 一致性。
我们再举一个例子:
from sklearn.preprocessing import StandardScalersc = StandardScaler()
sc.fit(X)
scaled_data = sc.transform(X)
当我们调用 sc 的 fit() 方法时，模型开始学习数据(即计算 X 的每一列的均值和标准差)。当我们调用 sc 的 transform() 方法时，转换发生(即缩放 X 的值)。这种。fit()/。transform() 一致性适用于所有 Scikit-learn 转换器。另外，注意导入 StandardScaler() 类时的一致性。那个类在预处理子包中。这就是为什么我们调用" from sk learn . sub _ package _ name "后跟 "import class_name" 。这种一致性适用于导入所有 Scikit-learn 转换器。
您还可以通过运行以下命令来同时调用 fit() 和 transform() 方法:
scaled_data = sc.fit_transform(X)
准则 6:不要记忆 Scikit-learn 语法，而是使用 help()
当进行机器学习时，您不需要记住 Scikit-learn 语法。你需要做的只是考虑你的模型的工作流程，并使用 help() 函数来查看语法。例如:
from sklearn.linear_model import LinearRegressionhelp(LinearRegression)
获取关于 Scikit 的帮助-学习线性回归类(图片由作者提供)
准则 7:区分模型参数和超参数
模型参数 在训练过程中学习它们的值。我们不手动设置参数值，它们从我们提供的数据中学习。例如，线性回归模型系数在训练过程中学习它们的值，以便找到最小化 RMSE 的最佳模型。
相反， 模型超参数 不从数据中学习它们的值。因此，我们必须手动为它们设置值。我们总是在创建特定模型时和开始训练过程之前设置模型超参数的值。例如， n_estimators 超参数是指集合模型中森林中的树木数量。其默认值为 100。我们可以将其更改为更高的值，以增加树的数量。这样做会提高模型性能，但也会消耗更多的计算能力。我们的目标是将它的值设置为最佳值，这样我们就可以在模型性能和计算能力之间保持平衡。
Scikit-learn 为其估计器中的超参数提供默认值。在大多数情况下，这些值不是最佳值，我们经常希望根据我们的数据和我们试图解决的问题找到最佳值。寻找超参数最佳值的过程称为 超参数调整 。
要了解有关超参数调整过程的更多信息，请阅读我的“T22 用简单英语解释 k-fold 交叉验证 T23”文章和“T24 验证曲线解释-绘制单个超参数的影响 T25”文章的“使用 k-fold 交叉验证进行超参数调整”部分。
准则 8: Scikit-learn 类不同于对象
通过改变超参数的值，可以从相同的类创建不同的对象(模型)。让我们看一个例子:
from sklearn.decomposition import PCApca_1 = PCA()
当我们以这种方式从 PCA() 类创建 pca_1 对象时，下面的默认超参数值被应用。
(图片由作者提供)
但是，我们可以修改超参数的值来创建不同的对象。
from sklearn.decomposition import PCApca_1 = PCA()
pca_2 = PCA(n_components=2)
pca_3 = PCA(n_components=3)
pca_4 = PCA(n_components=2,
svd_solver='*randomized*')
因此，您可以根据自己的需求自由更改超参数的值。
准则 9:不要用与训练相同的数据来评估你的模型
做任何类型的机器学习的主要意图是开发一个更通用的模型，它可以在 看不见的数据 上执行得很好。人们可以在训练数据上建立一个 100%准确或零误差的完美模型，但它可能无法对看不见的数据进行推广。一个好的 ML 模型不仅非常适合训练数据，而且可以推广到新的输入数据。模型的性能只能用在训练过程中从未使用过的数据点来衡量。这就是为什么我们经常将数据分为训练集和测试集。使用 k 重交叉验证可以更有效地完成数据拆分过程。要了解模型评估过程的更多信息，请阅读我的“用简单英语解释 k 重交叉验证”文章中的“使用 k 重交叉验证评估模型的性能”一节。
摘要
上述指导方针对我有效。本文包含的所有链接都是我自己的作品。您也可以阅读它们，并确定这些指南对学习 Scikit-learn 和机器学习的有效性。打下坚实的基础非常重要，这样你就不会中途放弃学习。
感谢阅读！
本教程由Rukshan Pramoditha，数据科学 365 博客作者设计创作。
在https://rukshanpramoditha.medium.com阅读我的其他文章
2021–04–05
9 Magic Command 增强您的 Jupyter 笔记本体验
它像魔法一样工作
你相信魔法吗？如果你不是，那么你绝对应该相信 Jupyter 笔记本魔法指令。这个名字听起来很荒谬，但是 Jupyter 笔记本包含了一个特殊的命令我们称之为魔法命令。
顾名思义，魔术命令或线魔术是我们在 Jupyter 笔记本中执行的一个特殊命令，以实现某些结果。magic 命令的工作方式是在您想要运行的命令中使用%符号。
有很多种魔法命令，但是在这篇文章中我只会展示我的 9 个顶级魔法命令。
让我们开始吧。
1.%谁
谁啊。谁是谁？这个命令是一个神奇的命令，可以显示 Jupyter 笔记本环境中所有可用的变量。下面让我给你看一个例子。
import seaborn as sns
df = sns.load_dataset('mpg')
a = 'simple'
b = 2
上面，我们创建了 3 个不同的变量；如果你在 Jupyter 笔记本的单元格中输入%who，它会显示所有现有的变量。
作者创建的图像
在上图中，我们可以看到我们拥有所有的变量，包括环境中预先存在的变量。
如果你想看到特定的变量，比如说只有 str 变量呢？这很容易。您需要在 magic 命令后键入对象类型。在这种情况下，它是%who str。
作者创建的图像
2.%timeit
这个神奇的命令很有趣。这个神奇的命令通过多次运行来评估代码执行速度，并产生执行时间的平均值+标准偏差。我们用一个例子来试试。
import numpy as np
%timeit np.random.normal(size=1000)
作者创建的图像
使用%timeit magic command，我们知道每个执行时间只偏离 341ns 左右。
当您想要查明代码执行和循环过程的稳定性时，此命令非常有用。
3.%商店
如果您在一个笔记本中处理一个项目，并希望将您拥有的变量传递到另一个笔记本中，该怎么办？您不需要将它保存在某个目标文件中。你需要的是使用%store魔法命令。
作者创建的图像
这是我们之前的 Jupyter 笔记本，带有包含 mpg 数据框的“df”变量。接下来，我想将这个“df”变量移到另一个笔记本中。我只需要打%store df。
作者创建的图像
“df”变量现在存储在 Jupyter 笔记本中，可以在不同的 Jupyter 笔记本中使用。让我们试着创建一个新笔记本并键入%store -r df。
作者创建的图像
就这样，我们的“df”变量被转移到另一个笔记本中，准备用于另一个分析。%store魔术命令的独特之处在于，您可以删除笔记本中的变量，并且您仍然可以将变量存储在%store魔术命令中。
4.%prun
另一个与时间有关的魔法命令。%prun是一个特定的神奇命令，用来评估你的函数或程序执行每个函数需要多少时间。
%prun的神奇之处在于它显示了一个表格，在这个表格中，您可以看到每个内部函数在语句中被调用的次数、每次调用所用的时间以及函数所有运行的累计时间。
让我们用一个例子来试着运行%prun魔法命令。
%prun sns.load_dataset('mpg')
作者创建的图像
如上图所示，我们可以看到语句中每个函数的执行时间，以及它们的时间加上累计时间。
5.历史百分比或历史百分比
你是不是一直在做这么多的分析，想知道自己做过什么样的事情，现在的状态是怎样的？当你不得不在单元格之间跳来跳去来运行你的函数时，你可能会比以前更困惑。
在这种情况下，我们可以使用%history魔法命令来查看您的活动日志，并追溯您已经做了什么。
试着在你的 Jupyter 笔记本电池上运行%history,看看输出是什么。下面是我的。
作者创建的图像
6.%pinfo
有时，当您在处理一个新的对象或包时，您想要获得所有的详细信息。如果你和我一样是懒惰型的，我们可以使用魔法命令%pinfo2来获取我们 Jupyter 笔记本单元格中的所有详细信息。
让我们尝试使用前面的 DataFrame 对象运行这个神奇的命令。
%pinfo df
作者创建的图像
使用这个神奇的命令，我们可以看到关于对象的所有信息以及我们可以使用的所有可用参数。
7.%%writefile
我们知道 Jupyter Notebook 不是开发和生产环境的最佳 IDE，但这并不意味着我们不能在 Jupyter Cell 中做到这一点。
如果您已经有了自己编写所有令人惊叹的函数，并希望将其保存在 python 文件中，该怎么办呢？当然，您可以打开另一个 IDE 并复制+粘贴该文件，但是有一种更简单的方法。我们可以使用魔法命令%%writefile来达到同样的效果。
让我们试着运行下面的代码。
%%writefile test.py
def number_awesome(x):
return 9
作者创建的图像
检查您当前的目录；您现在应该有一个新的 Python 文件了。
8.%pycat
如果您想用另一种方式，比如将 Python 文件读入您的 Jupyter 笔记本，该怎么办？你也可以使用%pycat魔法命令来完成。
让我们试着读一下我们之前的 Python 文件。
%pycat test.py
作者创建的图像
将出现一个新的弹出窗口，其中包含 Jupyter 笔记本中 Python 文件内的所有代码。
当您想要在 Jupyter 笔记本中试验许多生产和开发代码时，这个神奇的命令非常有用。
9.%quickref
你应该知道的最后一个魔法命令是%quickref。为什么这是应该知道的魔法命令？因为这个魔法命令详细解释了 Jupyter 笔记本中存在的所有魔法命令。
让我们试着在你的笔记本上运行它。
%quickref
作者创建的图像
就这样，你现在看到了你可以使用的每一个魔法命令的所有解释。那有多有用啊！
结论
Magic command 是 Jupyter 笔记本中的一个特殊命令，用于改善我们作为数据科学家的日常活动。有 9 个神奇的命令，我觉得有必要知道的人使用；它们是:
- %谁
- %timeit
- %商店
- %prun
- 历史百分比或历史百分比
- %pinfo
- %%writefile
- %pycat
- %quickref
希望有帮助！
如果您喜欢我的内容，并希望获得更多关于数据或数据科学家日常生活的深入知识，请考虑在此订阅我的简讯。
如果您没有订阅为中等会员，请考虑通过我的介绍订阅。
在数据科学项目中应该避免的 9 个错误
通过克服这些常见错误获得更好的结果
在数据科学中，就像许多其他领域一样，通过实践，比通过阅读书籍或研究该领域的技术方面，你会学到更多。当任何人开始他们的数据科学学习之旅时，您通常会花费大量时间和精力来学习许多方面、技能和术语。你将学习编码、数学和统计学、算法、可视化和商业基础。
尽管所有这些概念和主题都非常重要，但了解某个领域的理论并不意味着你会在该领域取得成功，或者可以毫无瑕疵地实施项目。有时候，作为初学者，我们倾向于做一些简单的事情来避免错误，我们这样做只是因为我们缺乏经验或者我们没有被教导去避免这些错误。
但是，一旦我们开始构建越来越多的项目，就要和不同的团队一起处理不同的主题。然后，在不同的数据集上，我们将发展如何处理任何问题的直觉，计划达到解决方案的具体步骤，并能够解决任何出现在你面前的问题。因此，尽管您会通过构建项目找到自己避免错误的方法，但您也可以通过与职业生涯中更远的数据科学家交谈来获得这些知识。
我曾经和许多数据科学家谈论过他们的学习之旅，以及他们希望在职业生涯中早点知道哪些东西可以帮助他们更快更好地进步。但是，正如我听到的很多，你通过做学得更好；当你经历某件事时，它会比你听到它时更好地留在你的脑海里。也就是说，阅读和获取信息永远不会是一件坏事。
在这篇文章中，我们将走过 9 个新手经常犯的错误，有时专家会有意或无意地导致错误的结果或导致项目花费更长的时间来完成。你可以在许多博客文章中找到这些错误，比如 SamrtBoost 、 JigSaw 、 CIO 以及其他在线资源。
№1:没有计划
让我们从最常犯的错误开始，即使作为专业数据科学家，也是在没有“攻击计划”的情况下进行项目通常，当我们遇到一个数据科学问题时，我们需要回答“为什么”数据会以这种方式运行，为了回答这个等式，我们需要清楚该做什么。那就是有一个计划和我们需要采取的步骤的想法。
№2:选择错误的可视化效果
如果有什么是我经常重复的，那就是，明智地选择你的视觉化。可视化在项目的所有阶段都很重要。例如，它在数据探索中至关重要，让你发现或错过模式或趋势。因此，请确保您了解可用的不同可视化工具、可以使用的图形和图表，以及哪种工具最能描述您的数据并帮助您更好地理解数据。
</5-online-data-science-courses-you-can-finish-in-1-day-5b60f353fa8e>
№3:不考虑数据中的偏差
在数据科学领域，有一句名言，“数据决定结果。”但是，不幸的是，我们通常对数据的收集方式和地点没有发言权。这就是为什么当我们使用一组数据来设置解决问题的步骤时，我们需要考虑这些数据可能有偏差或者不能很好地代表整个群体。这样做有助于我们避免做出错误的决策，避免最终得到扭曲的模型。
№4:没有根据现有数据优化模型
为了获得更好的结果，您的模型必须针对您拥有的数据进行优化；您的模型需要跟随数据随时间的变化。在机器学习中，这属于优化超参数的值以达到最佳性能。优化你的模型不只是一次性的步骤；通常，每次数据发生变化或其中发生变化时，您都需要返回并修改参数以适应该变化。
№5:更注重准确性而不是性能
这个错误是我们所有人在职业生涯的某个阶段都会犯的。准确性很重要，但不是好模型的唯一因素。解决方案的准确性取决于您选择的算法、您正在处理的数据以及您设置的参数。改变这些事情中的任何一个都会影响你的结果的准确性。所以，多关注于正确解释你的数据，你会得到很好的准确性。
№6:忽视相关性不等于因果关系
相关性和因果关系是两个非常不同的东西，但有时我们倾向于将它们联系起来，不仅在数据科学项目中，而且在我们的个人生活中。相关性是一种统计技术，用于表示两个变量或两个因素之间的关系。但是，仅仅因为关系存在，并不意味着因果关系也存在。所以，先测试数据再下结论。
</6-best-python-ides-and-text-editors-for-data-science-applications-6986c4522e61> [## 数据科学应用的 6 个最佳 Python IDEs 和文本编辑器
towardsdatascience.com](/6-best-python-ides-and-text-editors-for-data-science-applications-6986c4522e61)
№7:重用实现
这是另一个常见的错误:当我们在一个项目上花费大量时间，开发一种方法，并优化一个模型时，我们可能会认为这个模型可以应用于类似的问题，不需要任何修改。不幸的是，这种情况很少发生。每个问题都有自己的变量，需要量身定制的解决方案。因此，避免重复使用不同问题的含义。
№8:没有选择正确的工具
即使对我们中最专业的人来说，这也很容易出错。今天，似乎有无限多的工具可以在实施数据科学项目的不同阶段帮助您。但是，由于这个数字，我们可能会选择错误的工具，或者最终使用太多的工具。因此，从长远来看，在计划阶段花些时间为项目选择最好的工具将会节省您大量的时间和精力。
№9:忘记问题的商业方面
数据科学是一个跨学科的领域；它涵盖了广泛的应用程序和场景。所有这些应用都有商业的一面；这就是为什么他们永远不应该被忽视。因为业务方面是数据开始的地方，也是结果将被实现的地方，所以总是要花点时间来检查数据是如何和为什么被收集的，以及你将发现的洞察力将如何被用于未来的数据。记住，数据科学中的错误决策会导致数百万人。
</10-newsletters-you-need-to-subscribe-to-as-a-data-scientist-d12c7f33fbab>
最后的想法
当我第一次开始数据科学学习之旅时，我花了几个月的时间来掌握该领域的基础知识，复习我的数学和统计学，学习如何有效地可视化数据，如何以最佳方式交流信息，并学习一些基本的业务知识来支持我的模型选择。
但是，我要说的是，尽管我通过教程、在线课程和书籍学到了很多东西，但我通过第一年实际构建数据科学项目、与其他数据科学家合作以及探索数据科学的不同应用获得了最多的知识。通过这些互动，我学会了避免许多错误，只是为了有一个更有效的工作流程。
当你开始设计和实现项目时，我确信你会同意我们在这篇文章中所经历的 9 个错误。当你想起在数据科学职业生涯的早期犯下的一个错误时，你甚至会微笑。通过阅读这篇文章，我唯一的希望是初学数据的科学家在开始他们的职业生涯时知道应该避免什么，并且能够构建更好、更专业的项目。
</7-types-of-gigs-you-can-do-as-a-freelance-data-scientist-5b81f3c203af>
提高数据分析能力的 9 个技巧
探索性数据分析和数据预处理的熊猫技巧
数据科学家经常花大部分时间探索和预处理数据。说到数据剖析和理解数据结构，Pandas value_counts()是最受欢迎的。该函数返回包含唯一值计数的序列。结果序列可以按降序或升序排序，通过参数控制包含或排除NA。
在本文中，我们将探索熊猫value_counts()的不同使用案例。您将学习如何使用它来处理以下常见任务。
- 默认参数
- 按升序排列结果
- 按字母顺序排列结果
- 从结果中包含
NA - 以百分比计数显示结果
- 将连续数据绑定到离散区间
- 分组并呼叫
value_counts() - 将结果序列转换成数据帧
- 应用于数据帧
请查看笔记本获取源代码。
访问 Github Repo 获取其他教程
1.默认参数
Pandas value_counts()函数返回包含唯一值计数的序列。默认情况下，生成的序列按降序排列，没有任何NA值。例如，让我们从 Titanic 数据集中获取列“apolloed”的计数。
>>> df['Embarked'].value_counts()S 644
C 168
Q 77
Name: Embarked, dtype: int64
2.按升序排列结果
value_count()返回的序列默认为降序。我们可以将参数ascending设置为True来得到一个升序的结果。
>>> df['Embarked'].value_counts(**ascending=True**)Q 77
C 168
S 644
Name: Embarked, dtype: int64
3.按字母顺序排列结果
我们已经学习了参数ascending来获得按值计数 ASC 或 DESC 排序的结果。在某些情况下，按字母顺序显示我们的结果会更好。例如，这可以通过在value_counts()之后调用sort_index(ascending=True)来实现
>>> df['Embarked'].value_counts(ascending=True).**sort_index(ascending=True)**C 168
Q 77
S 644
Name: Embarked, dtype: int64
4.从结果中包含 NA
默认情况下，结果中会忽略包含任何NA值的行。有一种说法dropna来配置它。我们可以将值设置为False，以包含带有NA的行的计数。
df['Embarked'].value_counts(**dropna=False**)S 644
C 168
Q 77
**NaN 2**
Name: Embarked, dtype: int64
5.以百分比计数显示结果
进行探索性数据分析时，有时查看唯一值的百分比计数会更有用。这可以通过将参数normalize设置为True来实现，例如:
df['Embarked'].value_counts(**normalize=True**)**S 0.724409
C 0.188976
Q 0.086614**
Name: Embarked, dtype: float64
如果我们希望结果用百分号(%)格式化，我们可以如下设置熊猫显示选项:
>>> pd.set_option('display.float_format', **'{:.2%}'.format**)>>> df['Embarked'].value_counts(**normalize = True**)**S 72.44%
C 18.90%
Q 8.66%**
Name: Embarked, dtype: float64
通过调用pd.set_option('display.float_format', '**{:.2%}'.format**)，它更新 Pandas 默认显示设置，并应用于所有浮点值。要重置，可以调用pd.reset_option('display.float_format')。
另外，感谢大卫·B·罗森(博士)的建议。代替熊猫显示选项，我们可以简单地将结果转换成数据帧，并如下调用style.format('{:.2%}'):
df['Embarked'].value_counts(normalize = True).**to_frame().style.format('{:.2%}')**
如果你想了解更多关于熊猫的展示选项，你可以查看:
</8-commonly-used-pandas-display-options-you-should-know-a832365efa95>
6.将连续数据绑定到离散区间
Pandas value_counts()可用于通过bin参数将连续数据绑定到离散区间。类似于熊猫[cut()](/all-pandas-cut-you-should-know-for-transforming-numerical-data-into-categorical-data-1370cf7f4c4f)函数，我们可以传递一个整数或者一个列表给bin参数。
当一个整数被传递给bin时，该函数会将连续值离散化到个大小相等的箱中，例如:
>>> df['Fare'].value_counts(**bins=3**)**(-0.513, 170.776]** 871
**(170.776, 341.553]** 17
**(341.553, 512.329]** 3
Name: Fare, dtype: int64
当一个列表被传递到bin时，该函数会将连续值分成自定义组，例如:
>>> df['Fare'].value_counts(**bins=[-1, 20, 100, 550]**)**(-1.001, 20.0]** 515
**(20.0, 100.0]** 323
**(100.0, 550.0]** 53
Name: Fare, dtype: int64
如果你想了解更多关于宁滨的熊猫cut()，你可以看看:
7.分组依据并执行 value_counts()
Pandas [groupby()](/all-pandas-groupby-you-should-know-for-grouping-data-and-performing-operations-2a8ec1327b5)允许我们将数据分成不同的组来执行计算，以便更好地进行分析。一个常见的用例是按某一列进行分组，然后获取另一列的唯一值的计数。例如，让我们通过对“”列和“”列进行分组，得到不同“性”值的计数。
>>> df.groupby(**'Embarked'**)**['Sex']**.value_counts()**Embarked Sex
C male 95
female 73
Q male 41
female 36
S male 441
female 203**
Name: Sex, dtype: int64
如果你想了解更多关于groupby()的信息，可以查看:
8.将结果序列转换成数据帧
Pandas value_counts()返回一个序列，包括前面的 MultiIndex 示例。如果我们希望我们的结果显示为数据帧，我们可以在value_count()之后调用to_frame()。
>>> df.groupby('Embarked')['Sex'].value_counts()**.to_frame()**
to_frame()结果(图片由作者提供)
9.应用于数据帧
到目前为止，我们已经将value_counts()应用于熊猫系列，在熊猫数据帧中有一个等效的方法。Pandas DataFrame.value_counts()返回一个包含数据帧中唯一行计数的序列。
让我们看一个例子来更好地理解它:
df = pd.DataFrame({
'num_legs': [2, 4, 4, 6],
'num_wings': [2, 0, 0, 0]},
index=['falcon', 'dog', 'cat', 'ant']
)>>> **df.value_counts()****num_legs num_wings
4 0 2
6 0 1
2 2 1**
dtype: int64
通过在df上调用value_counts()，它返回一个以 num_legs 和 num_wings 为索引的 MultiIndex 系列。从结果中，我们可以发现 2 个记录有num_legs=4和num_wing=0。
类似地，我们可以调用to_frame()将结果转换成数据帧
>>> df.value_counts().**to_frame()**
df.value_counts()的结果。 to_frame() (图片由作者提供)
结论
在本文中，我们探索了熊猫value_counts()的不同用例。它非常方便，是探索性数据分析和数据预处理中最受欢迎的方法之一。
我希望这篇文章能帮助你节省学习熊猫的时间。我建议你查看一下value_counts() API 的文档，并了解你可以做的其他事情。
感谢阅读。请查看笔记本获取源代码，如果你对机器学习的实用方面感兴趣，请继续关注。
你可能会对我的其他一些熊猫文章感兴趣:
- 所有熊猫 json_normalize()你应该知道的扁平化 JSON
- 使用熊猫方法链接提高代码可读性
- 如何对熊猫数据帧进行自定义排序
- 为了数据分析你应该知道的所有熊猫移位()
- 何时使用 Pandas transform()函数
- 你应该知道的熊猫串联()招数
- 熊猫的应用()和变换()的区别
- 所有熊猫合并()你应该知道
- 在 Pandas 数据帧中处理日期时间
- 熊猫阅读 _csv()你应该知道的招数
- 用 Pandas read_csv()解析日期列应该知道的 4 个技巧
更多教程可以在 Github 上找到
应该开始使用 Python 数据类的 9 个理由
提高效率，减少样板代码
作者图片
从 3.7 版本开始，Python 引入了数据类(参见 PEP 557 )，这是一个定义包含和封装数据的类的新特性。
我最近开始在几个数据科学项目中使用这个模块，我真的很喜欢它。我马上想到两个原因:
- 较少的样板代码
- 可读性更强，代码可维护性更好
这篇文章总结了我的第一印象:我将用它来介绍数据类和它们旨在解决的问题，并介绍它们提供的 9 个不错的特性。
我有时会将使用 dataclasses 编写的类与原生 Python 实现进行比较，找出不同之处。
少说多做。让我们看一看🔍
PS:我不会涵盖关于数据类的所有内容，但是我们将介绍的特性应该可以让您快速了解。然而，如果您想要更深入的了解，可以看看参考资料部分的链接。
新到中？你可以每月订阅 5 美元，解锁我写的不限数量的关于编程、MLOps 和系统设计的文章，以帮助数据科学家(或 ML 工程师)编写更好的代码。
https://medium.com/membership/@ahmedbesbes
0 —数据类:整体情况
顾名思义，数据类是用来保存数据的类。这个模块背后的动机是，我们有时定义只作为数据容器的类，当我们这样做时，我们会花费大量的时间编写带有大量参数的样板代码，一个丑陋的__init__方法和许多被覆盖的函数。
数据类缓解了这个问题，同时提供了额外的有用方法。此外，由于 dataclasses 在 Python 生态系统中相对较新，所以它强制实施了诸如类型注释之类的现代实践。
👉数据类仍然是类。因此，您可以在其中实现任何自定义方法，就像在普通类中一样。
好，现在让我们看看他们的行动。
1 —定义类的代码更少
当我们定义一个类来存储一些属性时，它通常是这样的。
这是标准的 Python 语法。
当您使用 dataclasses 时，您首先必须导入dataclass,然后在您定义的类之前使用它作为装饰器。
下面是前面使用 dataclasses 的代码。
关于这个语法，需要注意一些事情:
- 样板代码更少:我们定义每个属性一次，我们自己不重复
- 我们对每个属性使用类型注释。虽然这不会强制类型验证，但是如果您使用类似于 mypy 的类型检查器，它会帮助您的文本编辑器提供更好的林挺。如果你不尊重类型，你的代码仍然可以工作，但是你的代码编辑器会发出不一致的信号。
类型注释有助于检测潜在的错误—图片由作者提供
- dataclasses 不仅仅允许您编写更紧凑的代码。dataclass decorator 实际上是一个自动添加其他方法的代码生成器。如果我们使用
inspect模块来检查哪些方法被添加到了Person类中，我们可以看到__init__、__eq__和__repr__方法:这些方法负责设置属性值、测试相等性并以良好的字符串格式表示对象。
作者截图
如果我们允许Person类支持顺序(参见关于比较的技巧 9)，我们也会有这些方法。
__ge__:大于或等于__gt__:大于__le__:低于或等于__lt__:低于
2 —支持默认值
您可以在保留注释的同时为每个属性添加默认值。
👉请记住，没有默认值的字段不能出现在有默认值的字段之后。例如，下面的代码不起作用:
3-对象的自定义表示
由于 dataclasses 已经添加了__repr__方法，当实例被打印到屏幕上时，它们有了一个很好的、人类可读的表示。
这使得调试更加容易。
这种表示可以被覆盖以实现您想要的任何定制消息。
4-轻松转换为元组或字典
实例可以很容易地序列化成字典或元组。当您的代码与需要这些格式的其他程序交互时，这非常有用。
5-冻结实例/不可变对象
使用 dataclasses，您可以创建只读对象。您所要做的就是在@dataclass装饰器内将frozen参数设置为True。
这样做时，一旦对象被实例化，就可以防止任何人修改属性值。
如果您试图将冻结对象的属性设置为新值，将会出现一个FrozenInstanceError错误。
作者截图
6 —不需要编写比较方法
当您使用标准 Python 语法定义一个类并测试具有相同属性值的两个实例之间的相等性时，您会得到以下结果:
这两个对象不相等，这很正常，因为Person类实际上没有实现测试相等的方法。为了增加平等性，你必须自己实现__eq__方法。这可能看起来像这样:
该方法首先检查两个对象是同一个类的实例，然后测试属性元组之间的相等性。
现在，如果您决定向您的类添加新属性，您必须再次更新__eq__方法。如果使用的话，__ge__、__gt__、__le__和__lt__也是如此。
这看起来像是不必要的代码输入，对吗？幸运的是，dataclasses 消除了这种困扰。
7-使用字段函数的自定义属性行为
在某些情况下，您可能需要创建一个仅在内部定义的属性，而不是在类被实例化时定义。当属性的值依赖于先前设置的属性时，可能会出现这种情况。
在这里，您可以使用 dataclasses 中的字段函数。
通过使用这个函数并将其init和repr参数设置为False来创建一个名为full_name的新字段，我们仍然可以实例化Person类，而无需设置full_name属性。
该属性在实例中尚不存在。如果我们试图访问它，就会抛出 AttributeError。
我们如何设置full_name的值，并且仍然将它保留在类的构造函数之外？为此，我们必须使用__post_init__方法。
_ _ post _ init _ _ 挂钩
dataclasses 有一个特殊的方法叫做__post_init__。
顾名思义，这个方法是在调用了__init__方法之后立即调用的。
回到前面的例子，我们可以看到如何调用这个方法来初始化一个依赖于先前设置的属性的内部属性。
请注意，field函数中的repr参数已被设置为True，以使其在打印对象时可见。在前面的例子中，我们不能将这个参数设置为True，因为属性full_name还没有被创建。
9-比较对象并排序
在处理包含数据的对象时，一个有用的特性是能够对它们进行比较，并按照您想要的任何顺序对它们进行排序。
默认情况下，dataclasses 实现了__eq__。为了允许其他类型的比较(__lt__(小于)、__le__(小于或等于)、__gt__(大于)和__ge__(大于或等于)，我们必须在@dataclass装饰器中将order参数设置为True。
**@dataclasses(order=True)**
实现这些比较方法的方式是获取每个定义的字段，并按照定义的顺序进行比较，直到出现不相等的值。
让我们回到Person类。假设我们想要基于age属性比较这个类的实例(这是有意义的，对吗？).
为此，我们必须添加一个字段，我们称之为sort_index，并将其值设置为age属性的值。
我们这样做的方法是调用我们在前面的例子中看到的__post_init__方法。
现在来自Person a 类的实例可以根据age属性进行排序。
让我们结束它
Dataclasses 提供了许多特性，允许您轻松地使用充当数据容器的类。
特别是，本模块有助于:
- 编写更少的样板代码
- 以可读的格式表示对象
- 实现自定义排序和比较
- 快速访问属性并检查它们
- 使用 post_init 等特殊方法来执行依赖于其他属性的属性初始化
- 定义内部字段…
资源:
在学习 dataclasses 的过程中，我查阅了许多资源(博客帖子、Youtube 视频、PEP、官方 python 文档)
下面是我发现的最有趣的帖子和视频的精选列表。
- https://docs.python.org/3/library/dataclasses.html
- https://realpython.com/python-data-classes/
- https://dev.to/dbanty/you-should-use-python-dataclass-lkc
- https://dev . to/isabelcmdcosta/data classes-in-python-are-nice-1 fff
- https://youtu.be/vBH6GRJ1REM
- https://youtu.be/vRVVyl9uaZc
- https://medium . com/minworks/understanding-python-data classes-part-1-c3ccd 4355 c34
- (法国博客文章)https://www.invivoo.com/dataclasses-python/
- https://flori mond . dev/en/posts/2018/10/reconciling-data classes-and-properties-in-python/
感谢阅读🙏
如果你已经做到这一步，我真的很感谢你的时间。
我希望我已经阐明了使数据类变得伟大的不同特性，并且我已经说服您开始使用它。
如果你仍然不相信，请告诉我你使用的替代方案。我真的很想听听他们的故事。
今天就这些了。直到下次👋
新到中？您可以每月订阅 5 美元，并解锁无限的文章— 单击此处。
帮助我在两周内解决所有 HackerRank SQL 挑战的 9 个技巧
这也将有助于您的 SQL 代码挑战之旅
作者照片
目前工作中的项目需要更多的 SQL 技能，所以我花时间使用 HackerRank 编码挑战平台来复习我的 SQL 知识。我花了两周多一点的时间(断断续续地工作、锻炼、带孩子去日间学校等等。)来完成网站上的所有 58 个 SQL 挑战，我从这个过程中获得了一些深刻的见解(并且从中获得了相当多的乐趣！).这篇文章可以被任何想进入数据科学世界或使用像 HackerRank 或 LeetCode 这样的编码网站为你的下一次 SQL 面试做准备的人阅读，即使你之前没有任何 SQL 知识。我确实放了一些代码给你们看一些简单的例子。大多数技巧都是关于充分利用这些 SQL 挑战，以便您可以从中获得最大收益，而不是教您如何解决这些问题。所以，如果你不懂 SQL 或编码，也不用担心。请坐下，放松，我们开始吧。
动机
Sylvester Sabo 在 Unsplash 上拍摄的照片
SQL 很无聊，因为它没有巧妙的算法或复杂的数据结构。没什么好吹嘘的。它需要更严格的计划和一步一步的执行来缩小你的表格和最终结果之间的差距。然而，这对每个数据分析/数据科学专业人员来说都是必不可少的。这就是我们获取黄金 mine🪙(数据)的方式。今天，人们使用更强大的语言/模块或工具(如 Python/Pandas 或 Tableau)进行大部分数据探索和操作。然而，我们仍然离不开 SQL，因为我们需要首先从那些“尘封”的关系数据库中获取数据。
当然，当你在像 HackerRank 或 LeetCode 这样的网站上处理具有挑战性的编码问题时，SQL 可以不那么无聊。通过正确的方法，每个具有基本 SQL 知识的人都可以从 SQL 编码挑战中获得乐趣，并在此过程中提升他们的 SQL 技能。这就是我将在接下来的会议中讨论的内容。
技巧 1:首先获得一些基本的 SQL 知识
显然，您需要有一些基本的 SQL 知识来开始这些挑战，尽管在这个过程中您会学到更多。学习基本的 SQL 是相对容易的，因为我们有大量的在线资源来帮助你。我使用了两个好的来源:
模式:数据分析的 SQL 教程 :非常有节奏，从基础到高级主题。它还提供了一个在线 SQL 环境，您可以使用教程中已经使用的数据库进行实时尝试——无需求助于 sqlfiddle 等。
SQLZoo :在我看来，比较新的学习者友好的。从最简单的子句(如 SELECT)到更复杂的连接，它会一直帮助您。如果你从来没有学过 SQL，在这里你会感觉更舒服。脸书招聘人员也推荐它。
一旦您觉得已经掌握了大多数命令的窍门，您就可以应对这些挑战了。没有必要过度学习你的基础知识。做所有这些挑战是一个很好的方式来实践你所学的，并在此过程中学习新的技巧。
技巧 2:仔细观察你的数据
查看您的数据并沿途做笔记是解决问题的一半。更好的是，在头脑中想象你的数据，或者使用白板(物理的或数字的)来帮助把查询放在一起。我们人类在视觉上思考时效率更高。所以离开白板，画出你的表格，放入一些样本数据，也许画线来显示关系。有些挑战相当复杂，你必须把所有的部分放在一个大的画面中，无论是在白板上还是在你的脑海中，以找到出路。在白板上做更容易(除非你是尼古拉·特斯拉，那么你就可以简单地用你的大脑解决问题)。🤔
另一个技巧是充分利用许多小而无用的实用查询来熟悉数据。查询不会直接为最终结果构建数据，而是向您展示数据的外观，揭示有价值的见解，并为您的想法提供即时反馈。您可以从:SELECT * FROM table LIMIT 10;开始，看看您的表是什么样子，然后尝试在不同的列上聚合，看看您是否可以获得一些见解。
SELECT *， COUNT(*) FROM table GROUP BY column;
也许可以更好地组织数据，并把它们放在另一个中间表( CTE )中以备后用。
WITH temp_table as ( SELECT xxx…)
SELECT * FROM temp_table
上面的代码片段是我所说的“扔掉的”实用程序查询的简单例子。显然，您可以做得更多，这取决于您正在解决什么问题。这种解决问题的方式也在真实数据科学家的工作中广泛使用，并有一个名字:探索性数据分析。为什么不现在就开始做呢？
提示 3:理解问题是解决问题的一半
我不记得有多少次我被卡住了，想知道为什么我完美的代码行不通，或者为什么问题就是无法解决，然后发现我误读了问题本身😜。这很愚蠢，但是当你急于在短时间内解决所有的挑战时(比如当你在做认证测试或面试时)，你会惊讶地发现自己是多么容易上当。
所以看题的时候要慢慢。不要跳过看似次要的语句。一个设计良好的挑战通常会在明文中隐藏重要的线索，仔细阅读问题就会发现它们。对模式、表关系以及问题的内容有一个明确的理解。你在这里度过的时间将会因为避免可怕的愚蠢的错误而得到巨大的补偿。
有时候慢就是快。
技巧 4:在编写代码之前制定一个计划
一旦你掌握了基本的 SQL 技能，清楚地理解了问题，并且知道了你的数据，现在是时候开始你的挑战了，首先制定一个计划。我怎么强调这有多重要都不为过。如果你只记得这篇文章中的一个提示，记住这个，制定一个计划。这是因为 SQL 挑战的本质是复杂的数据操作，通常需要多个聚合/抽象层来解决。通过对事物进行规划，在抽象的特定层面上进行思考，使认知成为可能，并防止我们钻得太深而无法回忆起全局。
我通常使用的思维方式是这样大声思考:问题是要求数据点 A 和 B，我可以通过聚合这 3 列来获得 A，通过使用窗口函数来打印出 c 列的有序列表来获得 B，好的，对于 A，我们需要从头开始创建列，我将使用内部连接来将它们放在一起。对于 B，窗口函数需要按 D 列划分，按 E 列排序，…
你看，我从顶层开始，逐步向下，一直到我选择的具体条款。把它说出来可以让我自己听到，加强我对问题和计划的记忆，从而帮助我思考。另一个好处是:在实际的 SQL 面试中，招聘人员通常希望你大声思考，这样他们会更好地了解你的思维过程。大多数时候，展示解决问题时的思维过程和解决问题一样重要，甚至更重要。如果你在所有的挑战中练习这一点，你会变得非常舒服(甚至有点兴奋)。大声说话会让你感觉更自信，让面试官看起来更自信。
技巧 5:不要为偷看讨论区而感到羞耻
在学习的时候偷看答案没什么好丢人的。你的目标是练习你的技能，而不是试图通过认证考试。有时候你会发现自己在一个挑战上陷得太久了。不要花费过多的时间去解决它。相反，使用 15 分钟规则:
“用 15 分钟的时间，尽你所能解决问题。但是，如果 15 分钟后没有答案，你必须问别人。”
这里应用 15 分钟规则的一个原因是你还在学习。有时，挑战需要使用一些你还不知道的技巧或条款。就像人们说的:你不知道你不知道的。在这上面花更多的时间也无济于事。另一个原因是，解决问题有时需要你退后一步，再次看到更大的画面，并弄清楚你是否陷入困境，需要走出去并改变路线。
培养你自由切换抽象层次的能力将对你的编码/数据分析职业生涯有很大的帮助。
当你从讨论板上得到提示并完成挑战后，停下来想一想为什么你会错过它？你的知识中有没有缺失的部分？你的思维/方法的盲点？再说一遍，慢慢来。你在学习。沉思时间是你将从这些挑战中学到最多的时候，通过找出你知识中的弱点并相应地改进它。
提示 6:选择有助于你实现目标的挑战
大多数算法/数据结构编码挑战往往有点“棘手”，这是理所当然的。然而，对于 SQL 来说，现实生活中要解决的问题更多的是简化复杂的关系，而不是想出数学问题的巧妙解决方案。总的来说，我发现 HackerRank 的 SQL 挑战大多遵循现实世界的挑战。然而，偶尔你还是会遇到在现实生活中很难发现的问题，比如著名的挑战打印素数。感觉就像有人把 Python 编码挑战放到 SQL 表单中，强迫你去解决。我在这里可能有偏见，但忽略这些挑战。还不如用 Python 来做。除了智能的乐趣之外，将 SQL 用于它没有被设计的用途不会有任何帮助。我们大多数人都不会为此而访问 HackerRank 或 LeetCode 这样的网站，不是吗？
技巧 7:停留一会儿，思考一下
一旦你破解了挑战，抵制诱惑，点击多汁的“下一个挑战”按钮！我强烈建议你反思自己解决问题的过程，问自己一些高质量的问题:
我用了什么子句？它们为什么会起作用？为什么其中一些不起作用？有更好的选择吗？我是如何解决这个问题的？我如何把它分解成更小的子问题？我汇总了哪些中间数据来得到最终结果？
我知道，有时在应对复杂挑战的兴奋中，很难停下来思考这些棘手的问题，这似乎会让我们慢下来，但相信我，这是更快的学习方法。
技巧 8:不要让艰难的挑战阻碍你参加认证考试
我得说一些“硬”挑战可能相当棘手。在这种情况下，您需要想出一些聪明的方法将所需的数据放在一起。我曾经使用 8 个 cte、两个窗口函数和多个连接来获得我想要的结果。但是认证测试更合理，更接近真实世界的问题。我的经验是，与提出新颖的旋转技巧相比，认证测试需要更仔细的问题阅读、模式剖析，甚至白板演示。所以，即使你遇到了一些挑战，也不要让它们让你气馁！当你觉得准备好了，参加认证考试，你仍然可以轻松通过！
技巧 9:分而治之。逐步解决这个问题
兰斯·阿斯佩在 Unsplash 上拍摄的照片
现在来看编码部分。我会在下面列出我认为对我有帮助的内容:
- 理解子查询和 CTE( 通用表表达式)的一个简单方法是将其视为其他编程语言中的一个函数。如果你不止在一个地方使用它，为什么不把它放到一个函数里呢？而子查询就像一个 lambda 函数，您可以在运行时编写它，并在使用后将其丢弃。它们有助于使您的代码可读性更强，概念上更容易理解，这对解决复杂的 SQL 挑战有很大的价值。
- 聚合是将原始数据提炼为更有意义、更接近问题所问内容的主要方式。 GROUP BY 有助于使用 SUM()、COUNT()、MIN/MAX()或 AVG()压缩数据，而窗口函数在项目级别执行聚合功能(最适合处理“前 N 名”类问题)。有时你需要许多级别/步骤的聚合才能到达你想要的地方。再次，查看您的数据和挑战问题，并仔细设计您的'聚合图'
- JOIN vs. LEFT JOIN:老实说，这两个是你需要的主要连接。当您希望只返回两个表中都有对的行时，请使用 JOIN，当您需要“左”表中的所有行时，请使用 LEFT JOIN，无论它们在“右”表中是否有对。
- 编写查询的顺序:最自然的方式是编写关于如何执行的查询:FROM > WHERE > GROUP BY > HAVING > SELECT > ORDER BY > LIMIT。忍住从 SELECT 开始的冲动。像机器一样思考。
- 从两端工作，你的桌子，问题问什么来解决问题。从数据/表格的角度:问问你自己，它可以用表格构建什么？什么样的聚合可以进一步提取数据？从最终结果方面:需要哪些数据？什么样的桌子有助于解决问题？想象一下，一些中级表可以帮助弥合差距。尽量两边都做，中间点会合。同样，在不同的抽象层次思考很有帮助。
奖金:
如果你破解了所有的挑战，就在 HackerRank 上进行你的 SQL 认证测试(初级和中级)。你能做到的！
结论
SQL 挑战与常规的算法/数据结构挑战略有不同。它要求你以一种更有组织的方式思考，构建你的代码，并在不同的抽象层次之间切换。掌握这些“慢”技能，你可能会发现自己比你想象的更快地通过挑战，最重要的是，它会让你为关键的 SQL 面试做好充分准备！
我希望你觉得这篇文章读起来很有趣，并从中学习到一些东西。如果你想更多地了解我对数据科学的思考、实践和写作，可以考虑报名成为 Medium 会员。每月 5 美元，你可以无限制地阅读媒体上的故事。如果你注册使用我的链接，我会赚一小笔佣金。
https://lymenlee.medium.com/membership
9 个未知的 Python 库会让你大吃一惊
Python 库让您的生活变得更加轻松
约书亚·索蒂诺在 Unsplash 上拍摄的照片
Python 编程充满了机会。它简单明了，有很多很酷的库和函数，可以让任务变得更容易。每个 Python 开发者都必须使用流行的库，比如 NumPy、pandas、date time、matplotlib、Tkinter 等等。然而，有一些鲜为人知的库可以让您的开发人员生活变得更加轻松，并改善您的编码体验。
在本文中，我将讨论九个您可能感兴趣的 Python 库。其中一些库甚至可以用来替代一些标准的 Python 库。所以他们绝对是要小心的！
1。钟摆
Pendulum 是一个很棒的 Python 库，可以处理日期和时间。这个库在涉及时区的情况下非常有用。关于这个库最好的部分是它继承了 Python DateTime 库，所以它也可以使用这个库。
我们可以使用下面一行代码来安装这个库。
pip install pendulum
想见识一下摆库的魔力吗？查看下面一行代码。
import pendulumpast = pendulum.now().subtract(minutes=2)
past.diff_for_humans()
使用钟摆模块的好处是用户友好。你可以得到令人兴奋的结果。
2。 神话般的
大多数运行在命令行上的 Python 应用程序看起来乏味无趣。神话般的可以用来给他们一个很好的改造，通过添加图像，彩色文本到控制台。
要安装 fantastic，我们需要运行下面的 python 命令。
pip install fabulous
要在终端上打印彩色文本，我们可以使用
from fabulous.color import bold, magenta, highlight_redprint(bold(magenta('''hello worldthis is some new lineand here is the last line. :)''')))
这个库支持 Python 2.6、2.7、3.3、3.4、3.5 和 PyPy。也可以在 Google Colab 上测试一下。
3。py webview
Pywebview 是一个 python 库，用于以 GUI 形式显示 HTML、CSS 和 JavaScript 内容。这意味着使用这个库，您可以将您的网站或网页显示为桌面应用程序。
使用以下命令安装 pywebview。
pip install pywebview
要启动一个显示给定网站的窗口，我们需要运行
import webviewwebview.create_window(“Test window”, “target domain name”, width=400, height=200, fullscreen=False, resizable= true)webview.start()
将为 webview 启动一个新窗口。
想 敬请期待 同更多类似 精彩 文章上 Python &数据科学 —做会员考虑使用我的推荐链接:【https://pranjalai.medium.com/membership。
4。 海博
Seaborn 是一个用于数据科学项目数据可视化的库。它建立在标准可视化库 Matplotlib 的基础上，可以使情节更加丰富多彩，更具吸引力
要安装它，我们可以运行以下命令。
pip install seaborn
要使用数据集绘制线图，我们可以使用:
import seaborn as snsdataset=sns.load_dataset(“dataset name”)sns.lineplot(x=”x-axis name”, y=”y-axis name”, data = dataset)
5。 Psutil
Psutil 是一个有用的跨平台 Python 库电话，可以获取与系统相关的信息。人们可以收集系统中正在进行的进程、CPU 利用率、RAM 使用等信息。
使用下面的命令安装 psutil。
pip install psutil
要计算系统在 3 秒间隔内的 CPU 利用率，我们可以运行:
import psutilpsutil.cpu_percent(interval=3)
6。 PyGame
顾名思义就是制作游戏的 Python 库。它包含许多图形和声音库，开发者可以用它们来制作游戏。此外，复杂的游戏逻辑和物理也可以使用 PyGame 的内置模块来实现。
要安装 PyGame，我们需要使用:
pip install pygame
7。 Pyforest
在从事数据科学项目时，我们需要导入许多库，如 NumPy、Pandas、Matplotlib 等。Pyforest 库帮助我们一起导入所有重要的库
我们只需运行以下命令。
pip install pyforest
你可以访问所有的库，比如 NumPy，Pandas，Matplotlib，seaborn 等等。Pyforest 还安装了其他一些重要的库，如 os、tqdm、re 等。
8。 摩丁
Modin 是一个库，它通过利用机器的所有内核而不是单个内核来改进你的熊猫工作流程。这尤其有助于提高处理大型数据集时的性能。
您可以使用这一行代码安装这个库。
pip install modin
现在，您可以像这样安装它——这样您就不需要对代码做进一步的修改。
**import** **modin.pandas** **as** **pd**
这就是你需要做的。不需要对代码做进一步的修改。
9。 熊猫 _ 剖析
这是一个 Python 库，可用于获取数据集、其属性以及属性间相关性的概述。
可以使用下面显示的命令安装它。
pip install pandas-profiling
要获得数据框的分析并将分析结果保存为 web 格式，我们可以使用
from pandas_profiling import ProfileReportreport = ProfileReport(dataframe)report.to_file(output_file=’output.html’)
您可以进一步将此报告保存为 HTML 或 pdf 文件，以供进一步分析。
如果你正在寻找更多 python 的超酷功能，那么——这里有一本关于 python 编程的书,我肯定会向所有初学者推荐。
结论
这些是一些鲜为人知的库，可以用来改善您的编码体验，并取代现有的标准 Python 库。您可以在文档页面中获得关于这些库的详细教程，因为大多数库都是开源的。
作为开发人员，这些库肯定会让您的生活更加轻松。
注: 本文包含代销商链接。这意味着，如果你点击它，并选择购买我上面链接的资源，你的订阅费的一小部分将归我所有。
然而，推荐的资源是我亲身经历的，并在我的数据科学职业生涯中对我有所帮助。
在你走之前……
如果你喜欢这篇文章，并且想要继续关注更多关于 Python &数据科学的精彩文章，请点击这里https://pranjalai.medium.com/membership考虑成为一名中级会员。
请考虑使用我的推荐链接注册。通过这种方式，会员费的一部分归我，这激励我写更多关于 Python 和数据科学的令人兴奋的东西。
还有，可以随时订阅我的免费简讯: Pranjal 的简讯 。
你可能没听说过的 9 种有用的熊猫方法
Zoe Nicolaou 在 Unsplash 上拍摄的照片
它们可以让你的日常工作更容易、更快捷。
在本文中，我想快速展示一些有用的pandas方法/函数，它们在您的日常工作中会派上用场。为了管理期望，这不是一篇展示pandas基本功能的文章，也没有特别的方法主题。事不宜迟，我们开始吧！
1.哈斯南斯
检查一个系列/数据帧是否包含缺失值的方法有很多，包括专用库，如missingno。检查数据帧的列是否包含缺失值的简单方法如下:
df["column"].isna().any()
或者，我们可以使用 pd 的hasnans方法。略少打字的系列:
df["column"].hasnans
一个缺点是这种方法不适用于数据帧，尽管我们可以很容易地将它与列表理解结合使用:
[df[col].hasnans *for* col *in* df.columns]
使用这种方法，我们自然会丢失列名。所以我认为hasnans的主要用例是对单个列进行快速检查。
2.改变
transform方法用于对整个数据帧进行转换，或者对选定的列进行不同的转换。然而，使这个方法脱颖而出的是它返回一个与输入形状相同的对象。
这就是为什么在处理聚合时transform可以节省大量时间。通常，如果我们想要在原始数据帧中有一些聚合值(想想每组的总和或平均值)，我们可以使用groupby创建一个新的、更小的数据帧，然后将其合并回原始数据帧。这有点耗时，并且会产生不必要的中间对象。
有了transform，我们可以一气呵成！让我们创建一个包含一些商店 id 及其多日销售额的数据框架(为了简单起见，我们跳过日期)。
作者图片
使用下面的代码片段，我们可以很容易地将每个商店的销售额相加:
作者图片
transform绝对简化了流程。transform的一个更高级的用例可以用于聚合过滤。例如，我们希望提取关于销售超过 75 件商品的商店的行。并且理想情况下不会在输出数据帧中创建新的列。我们可以这样做:
作者图片
3.merge_asof
原则上，这个函数类似于一个标准的左连接，但是，我们匹配最近的键而不是相等的键。这将通过一个例子变得更加清楚。
我们还需要知道使用merge_asof有 3 个连接方向(定义改编自文档):
backward—对于左侧数据帧中的每一行，我们选择右侧数据帧中最后一行，其on键小于或等于左侧键。这是默认的。forward—对于左侧数据帧中的每一行，我们选择右侧数据帧中的第一行，其on键大于或等于左侧键。nearest—对于左侧数据帧中的每一行，我们搜索选择右侧数据帧中其on键在绝对距离上最接近左侧键的行。
另一件要考虑的事情是两个数据帧都必须按键排序。
我不会尝试重新发明轮子，我将使用文档中提供的例子。这里，我们有两个数据框架，一个包含交易信息，另一个包含报价。两者都包含详细的时间戳(包括毫秒)。
然后，我们在报价时间和交易时间之间的2ms内合并两个数据帧:
以下数据帧的结果是什么:
作者图片
通过从输出帧到两个数据帧的几个例子，最容易理解合并的逻辑。
4.插入
这是一个简单而方便的方法。我们可以用它在数据帧中的特定位置插入一列。最常见的用例是当我们想要添加一个包含额外信息的列，以便更容易地分析输出时。为了我们和利益相关者的方便，这些信息作为第一栏将是最有用的。我们可以通过下面的代码片段做到这一点:
作者图片
5.激增
当我们想要将一个数据帧中的列表展开成多行时，explode 非常有用。想象一下下面的情况——我们有两个 id，并且在列表中为每个 id 存储了多个值。我们希望每个 ID-值组合都有一行。
作者图片
df.explode("values", *ignore_index*=True)
作者图片
6.潜艇用热中子反应堆（submarine thermal reactor 的缩写）
当处理包含字符串的列时，我们可以使用str，它允许我们使用各种方便的方法，这些方法可以以矢量化的方式应用于整个列。例如，我们可以很容易地将包含完整地址的列拆分成单独的部分。首先，让我们创建数据框架。
作者图片
然后，我们可以使用str.split方法来创建新的列。
作者图片
另一种可能性是使用str.replace方法来修改字符串。
7.阅读 _ 剪贴板
当您经常使用 Excel/Google 工作表或接收此类文件中的数据时，这种方法尤其有用。使用 read_clipboard，我们可以使用计算机的剪贴板轻松地将数据从源表加载到pandas。这样，我们可以绕过将文件保存到.csv或.xls的需要。自然，这对于一些小的、特别的分析非常有用。
作者图片
上面你可以看到 Google sheets 中一个简单表格的例子。我们选择范围，按下cmd+c(或者对于 Windows 按下control+c，然后使用下面的代码片段轻松地将数据加载到 Python 中:
pd.read_clipboard()
什么会返回以下内容:
作者图片
8.evaluate 评价
eval方法使用字符串表达式来有效地计算数据帧上的操作。根据文件:
支持以下算术运算:
+、-、*、/、**、%、//(仅限 python 引擎)以及以下布尔运算:|(or)、&(and)、和~(not)。此外，'pandas'解析器允许使用与相应的位操作符具有相同语义的[and](https://docs.python.org/3/reference/expressions.html#and)、[or](https://docs.python.org/3/reference/expressions.html#or)和[not](https://docs.python.org/3/reference/expressions.html#not)。
作者图片
9.挤压
还记得当您想从一个数据帧中提取一个标量值，经过一些过滤后，您使用.values[0]来访问最终输出的情况吗？然后你可能会想，一定有更好的方法来做这件事。确实有——squeeze方法。
首先，让我们定义一个数据帧:
然后，我们可以尝试访问数据帧中的特定值，例如:
df.loc[df["a"] == 3, "b"]
输出如下所示:
2 6.0
Name: b, dtype: float64
对于一个简单的print来说，这是可以的，但是当我们想把这个值赋给一个变量或者甚至把它放在另一个数据帧中时，这可能会导致一些问题。
获取标量值的优雅解决方案是在末尾添加squeeze方法:
df.loc[df["a"] == 3, "b"].squeeze()
回报:
6.0
在你走之前
你可以在我的 GitHub 上找到本文使用的代码。此外，欢迎任何建设性的反馈。我将非常高兴听到一些pandas功能，使您的工作更容易！你可以在推特或评论中联系我。
喜欢这篇文章吗？成为一个媒介成员，通过无限制的阅读继续学习。如果你使用这个链接成为会员，你将支持我，不需要你额外付费。提前感谢，再见！
您可能还会对以下内容感兴趣:
[## 使用 datapane 将您的交互式可视化嵌入到中型帖子中
towardsdatascience.com](/embed-your-interactive-visualizations-in-medium-posts-using-datapane-9613314f048d)
从 10000 英尺的高度看人工智能
播客
扬尼克·基尔彻谈人工智能在不久的将来的趋势、挑战和机遇
编者按:TDS 播客由 Jeremie Harris 主持，他是数据科学导师初创公司 SharpestMinds 的联合创始人。每周，Jeremie 都会与该领域前沿的研究人员和商业领袖聊天，以解开围绕数据科学、机器学习和人工智能的最紧迫问题。
曾经有一段时间，人工智能研究人员可以期望在 arXiv 上阅读该领域发表的每一篇新论文，但今天，情况不再如此。最近人工智能研究活动的爆炸式增长已经把跟上新发展变成了一项全职工作。
幸运的是，像 YouTuber、ML PhD 和太阳镜爱好者 Yannic Kilcher 这样的人把将 ML 新闻和论文提炼为像你我这样的凡人可以消化的形式作为他们的业务。我向任何对 ML 研究感兴趣的 TDS 播客听众强烈推荐他的频道——这是一个非常棒的资源，实际上我最终设法理解注意力的方式就是你需要的全部文件。
Yannic 和我一起谈论他从多年的跟踪、报道和人工智能研究中学到的东西，包括他预计将在未来几年塑造人工智能历史进程的趋势、挑战和机遇。
以下是我在对话中最喜欢的一些观点:
- Yannic 前阵子放弃了阅读他能找到的每一篇有趣的 arXiv 论文。今天，他引用 arXiv、Reddit 和 Twitter 的组合作为他获取最新消息的主要来源。
- 众所周知，媒体对人工智能的报道可能会被夸大(例如， 索菲亚，第一个拥有公民身份的机器人，现在想要一个机器人宝宝 )，一维且消极倾斜( Flasehoods 更有可能拥有大型语言模型 )。但扬尼克强调了几个他特别怀疑的具体比喻和主题。特别是，他指出“人工智能可能会产生令人印象深刻的输出，但它们并不真正理解任何东西”(好像人类的大脑和人类的理解与现代人工智能运行的统计推理过程根本不同)。他还夸大了对人工智能偏见的担忧，以及关于人工智能不安全的耸人听闻的头条新闻，因为它们在特定场景下产生了令人讨厌的输出( 使用 OpenAI 的 GPT-3 的医疗聊天机器人告诉一个假病人杀死自己 )。
- 尽管过度强调人工智能伦理，Yannic 仍然同意人工智能研究中有重要的伦理问题需要解决。这些问题包括对人工智能可能在多大程度上实现技术官僚威权主义的担忧，人类在由算法运行的世界中的角色，以及算法无法“脱离剧本”并适应特殊情况或超出分布的问题。虽然他确实认为人工智能对齐是一个值得担心的问题，但他认为人工智能的恶意和专制应用在下一代或两代人身上更令人担忧。
- 人工智能领域的许多人不愿意将人工智能的行为拟人化。这可能是一件好事:将模型视为统计推理机而非“思维机器”确实有助于对模型行为进行更冷静的分析。但它也有不利的一面——有时将人工智能视为“理解”概念，或以更像人类的方式处理信息是有用的(此外，如果人类的思维真的只是大脑中神经处理的产物，那么没有理由想象机器最终不会像我们一样“理解”和“思考”，如果它们在某些情况下还没有做到这一点)。扬尼克认为，人工智能研究人员很可能倾向于低估拟人推理的价值，将其作为一种为人工智能系统的行为建立直觉的方式。
你可以点击这里在 Twitter 上关注扬尼克，或者点击这里查看他的 YouTube 频道。
章节:
- 0:00 介绍
- 1:20 扬尼克的 ML 之路
- 7:25 选择 ML 新闻
- 11:45 艾伦理→政治话语
- 17:30 人工智能校准
- 24:15 恶意使用
- 32:10 对角色的影响
- 39:50 引入人类思维
- 46:45 数学与大数
- 51:05 概括的标准
- 58:05 人工智能的未来
- 1:02:58 总结
2021 年 NLP 回顾展
是时候回顾一下自然语言处理领域今年的一些亮点了
图片由莲蓬头；根据知识共享署名 3.0 获得许可
在过去的一年中，自然语言处理(NLP)领域发生了很多事情，我想花一些时间来反思一下我个人的一些亮点。
TL；速度三角形定位法(dead reckoning)
对于那些赶时间的人:
- 如果你只读了 2021 年 NLP 上的一篇文章，那就让它成为《纽约客》上的聊天机器人问题(T4)
- 如果你只读了今年的一篇论文，我强烈推荐关于随机鹦鹉的危险:语言模型会不会太大？
- 如果你只想花时间在一个课程上，以达到最先进的 NLP 的速度，请查看拥抱脸的课程(免费！)
- 如果你在 NLP 上只看了一个视频，我发现谷歌的 LaMDA 演示给人印象非常深刻
一月
让我们从一个有趣的问题开始:果蝇能学习单词嵌入吗？本文研究生物学和神经网络之间的关系。虽然从生物学中获得了高层次的灵感，但当前一代的深度学习方法不一定符合生物学现实。这提出了一个问题，即生物系统是否可以进一步为新网络架构和学习算法的发展提供信息，从而导致机器学习任务的竞争性能或提供对智能行为的更多见解。
为了做到这一点，研究人员使用了果蝇的模拟大脑，这是神经科学中研究得最好的网络之一。事实上，他们能够显示，令人惊讶的是，这个网络确实可以学习单词和它们的上下文之间的相关性，并产生高质量的单词嵌入。
二月
跟踪自然语言生成(NLG)的进展是很棘手的，因为就其本质而言，NLG 任务没有固定的正确与错误的定义。为了克服这一挑战并跟踪 NLG 模型的进展，一个涉及来自 44 个机构的 55 名研究人员的全球项目提出了 GEM (生成、评估和度量)，这是一个以评估为重点的 NLG 生活基准环境。
GEM 项目的最终目标是实现对数据和模型的深入分析，而不是关注单个排行榜分数。通过测量跨越许多 NLG 任务和语言的 13 个数据集的 NLG 进度，希望 GEM 基准也可以为未来使用自动和人工度量评估生成的文本提供标准。
研究人员已经向 NLG 研究社区开放了该项目，资深成员将帮助新来者做出贡献。GEM 基准位于 gem-benchmark.com 的，更多信息也可以在拥抱脸的数据中心找到。
三月
声明:我为 AWS 工作，对下一个 100%有偏见，但我真的认为它很酷:)
拥抱脸和 AWS 的合作关系已经彻底改变了我的工作。我敢肯定，没有人阅读这个博客需要介绍拥抱脸。今年 3 月宣布的合作伙伴关系引入了新的拥抱脸深度学习容器(DLC)，使得在亚马逊 SageMaker 中训练和部署拥抱脸变压器模型比以往任何时候都更容易。
这个惊人的 Github 库由 Philipp Schmid 开发，让你尝试所有的新特性，从分布式培训到模型部署&自动扩展。
四月
剑桥大学的化学系和物理系在四月份发表了一篇非同寻常的论文，其中描述了他们如何训练一种不同的语言模型。
研究人员使用序列嵌入，一种众所周知的 NLP 技术，将蛋白质序列转换成 200 维嵌入向量。如果你想知道，200 维确实被认为是如此复杂信息的低维表示！这项技术允许团队训练一个语言模型，该模型优于几种现有的机器学习方法，用于使用公开可用的数据集预测蛋白质液-液相分离(LLPS)。
现在，我不会假装我理解什么是 LLPSs，但是从我的理解来看，它们是理解蛋白质的分子语法和发现潜在错误的基础。这可能是癌症和神经退行性疾病(如阿尔茨海默氏症、帕金森氏症和亨廷顿氏症)研究取得突破的第一步。
五月
我很确定你曾经尝试过和你的智能家居助手进行一次适当的对话。我知道我有过，但从来没有持续过那么久。除了一两次交流之外，助理通常无法掌握谈话的内容，这种尝试通常以令人沮丧的“我不确定我理解这个”而告终。
在今年 5 月的谷歌 I/O 大会上，公司宣布了其在对话式人工智能领域的最新进展， LaMDA (对话应用的语言模型)。这是一种会话式的语言模式，似乎能够进行更长时间的对话。他们与冥王星和纸飞机对话的演示给人留下了深刻的印象。值得称赞的还有他们披露的事实，即现在还为时尚早，并指出该模式的一些局限性。我真的希望谷歌能在某个时候发布一个版本来玩玩。
六月
如果你喜欢弱者挑战强者的故事，这本书可能适合你:
作者图片
这是 Connor Leahy 和 Leo Gao 之间的一次交流，启动了 EleutherAI ，这是一个由志愿者研究人员、工程师和开发人员组成的分散式基层集体，专注于人工智能对齐、扩展和开源人工智能研究。成立于 2020 年 7 月，他们的旗舰项目是 GPT-近地天体系列模型，旨在复制 OpenAI 开发的 GPT-3。他们的 Discord 服务器已经开放，欢迎贡献者。
六月，他们发布了最新的模型，GPT-J，它有 60 亿个参数，相比之下 GPT-3 有 1750 亿个参数。尽管规模小得多，但 GPT J 在编写代码等专业任务上胜过它的大兄弟。
我发现这种趋势非常令人鼓舞，并很兴奋地期待着 EleutherAI 的下一步。
七月
七月份《纽约客》发表了一篇关于语言模型偏见的文章。这在 NLP 社区中并不是一个新话题。然而，对于像《纽约客》这样的杂志来说，选择这样的主题凸显了现代 NLP 模型的重要性和关注点。这让我想起了 2020 年《T2 卫报》关于 GPT-3 的文章——这是主流媒体关注小众话题的时刻。
《纽约客》的这篇文章关注的是语言模型如何反映我们的语言，最终反映我们自己。尤其是这句话让我印象深刻:“我们正被迫面对作为技术问题的人类基本奥秘:我们对自己内心的黑暗知之甚少，我们对这种黑暗的控制又是多么微弱。”
八月
接下来的这个故事引起了《纽约客》文章的共鸣，因为在八月玛格丽特·米歇尔加入了拥抱脸。米切尔在 2021 年 2 月被解雇之前一直是谷歌的伦理人工智能研究员。她与人合著了一篇关于大型 NLP 模型相关成本和风险的论文(笔名为 Shmargaret Shmitchel ):
我们已经确定了与越来越大的 LMs 的热潮相关的各种各样的成本和风险，包括:环境成本(通常由那些没有受益于由此产生的技术的人承担)；财务费用，这反过来又设置了进入壁垒，限制了谁能对这一研究领域作出贡献，以及哪些语言能从最先进的技术中受益；机会成本，因为研究人员将精力从需要较少资源的方向上转移；以及实质性伤害的风险，包括刻板印象、诋毁、极端主义意识形态的增加和错误逮捕，如果人类遇到看似连贯的 LM 输出，并认为它是对所说的话负责的某些人或组织的话。
我很高兴看到 Mitchell 加入了 Hugging Face，这是一家推动开源机器学习和繁荣社区的公司。如果你想更多地了解她在拥抱脸的工作，可以看看她的视频关于开发机器学习项目时要记住的价值观。
九月
说到开源 NLP，爆炸也经历了很棒的一年。这是最受欢迎的 NLP 图书馆之一 spaCy 背后的公司。9 月份，他们在首轮融资中以 1.2 亿美元的估值筹集了 600 万美元。
不得不承认，2021 年的 spaCy 我还没跟上。我主要专注于在变形金刚库上提升自己的技能。因此，我很惊讶地看到 spaCy 今年早些时候在 spaCy 3.0中发布的所有新功能。2022 年我一定会再次把目光投向 spaCy。
Explosion 不仅提供了一个最流行的 NLP 库，他们还创建了 Prodigy，一个现代注释工具。这很重要，因为创建更好的模型的一个潜在方法是首先创建更好的训练数据——这就是数据注释工具派上用场的地方。
看到一位女性( Ines Montani )成为一家人工智能公司的首席执行官是一个不错的转变:)
十月
十月，NLP 峰会 2021 召开。本次会议展示了 NLP 最佳实践、真实世界的案例研究、在实践中应用深度学习&迁移学习的挑战，以及您今天可以使用的最新开源库、模型&变形金刚。
许多 NLP 圈子里的知名演讲者在这次会议上发言，其中一些亮点是:
- 为什么&如何关注 NLP 伦理？
- 科学文献的极端概括
- 利用人工智能实现经济复苏
你仍然可以在他们的网站上点播所有的讲座。
十一月
拥抱脸有相当一年，我不得不再次提到他们。11 月，该公司发布了他们课程的第二部分，帮助你快速入门最先进的 NLP 模型。本课程将带您踏上一段旅程，首先从高级管道 API 开始，让您通过两行代码利用 NLP 技术。然后，它逐渐深入到变形金刚的堆栈中——在你意识到之前，你已经从头开始创建了自己的因果语言模型。
第二部于 11 月推出，伴随着一系列讲座和会谈，你可以在这里找到。
十二月
非常合适的是，这个列表中的最后一项也提供了 NLP 领域未来的展望。12 月，Louisa Xu 在《福布斯》上发表了她关于自然语言的黄金时代的文章。
这是一篇很棒的文章，介绍了目前最有影响力的三家 NLP 公司。她的总结和展望非常到位，我让她自己来说:
每一家从语言中获取价值的公司都会从 NLP 中受益，NLP 是机器学习中最具变革潜力的分支。语言几乎是我们所有交往中的最小公分母，我们从语言中获取价值的方式在过去三年中发生了巨大的变化。NLP 的最新进展具有极大的潜力来提高业务绩效。它甚至有希望将信任和诚信带回我们的在线互动中。大型现任者是第一批跳上船的，但真正的希望在于下一波 NLP 应用和工具，它们将把围绕人工智能的宣传从意识形态转化为现实。
结论
所以，现在你知道了，这些是我个人在 NLP 的 2021 年的亮点。我希望你喜欢这个总结，如果能听到你在过去 12 个月里在 NLP 的个人亮点，那就太好了。请对这篇博文发表评论或直接联系。
关于如何在商用硬件上加速 NLP 模型推理的 3 分钟阅读。
罗盘导航地景加速推理
序幕
一种在使用串行和/或并行专用硬件的数据中心中加速服务器端模型推断被证明是简单的(理解为简单而不容易)。一段时间以来，数据中心一直在使用专门的硬件，即:图形处理单元(GPU)、现场可编程门阵列(FPGAs)和专用集成电路(例如谷歌 TPU) ，这要感谢云服务提供商，他们使这些硬件变得非常容易访问。现在，像 FPGA 这样的专用硬件甚至出现在智能手机这样的消费设备上(iPhones 上的FPGA)，所以，手机上的 ASICs 不是想象中的事情。像东京的 LeapMind 这样的公司正在积极开发专用硬件，用于受约束和边缘设备的训练和加速推理。但使用专门的硬件来加速推理是一个非常狭窄的世界，并留下了巨大的空间。但幸运的是，已经有很多关于在没有任何专门硬件的情况下，即在商品硬件和 中加速推理的研究，这篇文章将作为一个指南针，帮助你浏览可用的选项。
最大的问题
如何在服务器端和客户端(胖客户端和受限/边缘设备)的商用硬件中加速模型推理？
但是为什么呢？
由于“推理预算”通常非常少，因此有几个原因可以加速商用硬件上的模型推理，尤其是在客户端。此外，由于延迟和带宽的问题，并不是所有基于 ML 的解决方案都能提供服务器端推理的最佳用户体验。对于一些应用来说，数据 隐私是另一个挑战:消费者不希望数据像智能手机一样离开他们的设备。像 差分 隐私 和 联合 学习 这样的创新确实有助于缓解担忧，但实现起来很复杂。因此，我们最好在更紧的推理预算内寻找一些操作选项。
基于自然语言处理模型的心理模型
在商品硬件中，加速推理是棘手的，因为它不是推理预算等式中的唯一变量。模型尺寸和我们可能权衡的精确度也是至关重要的。因此，这里有一些技术可以帮助 压缩模型(可选)和/或加速推理，而不会在准确性上做出巨大的妥协。
这篇文章的范围是分享关于可用选项的广泛观点，并给出一般性建议。所以在这篇文章中，你不会找到太多关于这些技术如何在内部工作的信息。我会写一篇后续。
可用选项
NLP 中的任何推理请求都有两部分:一是输入 标记化二是实际模型 预测调用。HuggingFace 通过将标记化的最新研究民主化，钉死了标记化部分。这里有一个 概要 。
商用硬件上的 NLP 推理—可用选项(图片由作者提供)
胖客户端/服务器端推断(例如 Outlook 自动响应)
商用硬件上胖客户端和服务器端推理的路径(图片由作者提供)
瘦客户端推理(例如基于浏览器)
瘦客户端路径，如基于浏览器的推理硬件(图片由作者提供)
受限/边缘设备推断(例如智能手机、物联网设备)
边缘或受约束设备推断的路径(图片由作者提供)
想法/评论？
- 【https://huggingface.co/blog/accelerated-inference
- https://towards data science . com/low-precision-inference-with-tensorrt-6 EB 3c da 0730 b
- https://en . Wikipedia . org/wiki/专用集成电路
对 PCA 的 3 分钟回顾:压缩和恢复
3 分钟回顾
PCA 最便捷的视觉笔记
照片由乔尼·克洛在 Unsplash 上拍摄
如今，数据科学家和 ML 工程师的知识深度通常通过他们对算法的数学和实现细节的反馈来判断。我不同意这种做法。现实是，没有人能记住每一个细节，这没关系。你不需要知道如何实现一个算法来应用它。即使你知道如何实现它，面对实际问题时，你仍然会错误地判断何时以及如何正确地使用它。
提取直觉以便正确应用是关键。
我正在创建这个 3 分钟的算法回顾系列，重点放在直觉部分。通过一个简单的算法是什么、如何、为什么和何时的例子，你可以很快很容易地抓住要点。
在今天的文章中，让我们深入研究 PCA——最重要的降维算法。
PCA 做投影降维。
直观上，它只是从数据点到一个更低维的超平面画出正交线，找到着陆点。超平面的轴基于它们捕获的方差的最大化来选择。他们捕捉的差异越多，预测保留的信息就越多。通过这种轴选择方案，PCA 实现了最小的信息损失，并对数据进行了良好的压缩。
最小的例子:从 4D 到 2D 的投影
让我们用sklearn和著名的 Iris 数据集来演示它是如何工作的。
作者图片
从代码中，我们看到有 150 个例子和 4 个特性列。很难直接可视化 4D 的数据，让我们使用sklearn.decomposition.PCA将它们投影到 2D。
作者图片
pc2是两个最高级的主成分——这里的两个行向量。它们在原始特征空间中，因此是 4 维的。
我们要投影到的 2D 平面由pc2中的这两个向量(主分量)构成。它们是平面的基向量。让我们称他们为u和v。这架 2D 飞机生活在 4D 空间。从原始特征空间——4D 空间的角度来看，PCA 所做的是将原始 4D 数据点投影到这个 2D 平面上。
矩阵X_reduce的形状为(150，2)，即约化 2D 空间中的 150 个例子。每一行是一个有两个坐标的向量。请记住，第一个数字对应于u上的系数，第二个数字对应于v上的系数。
作者图片
这样，原始(150，4)数据被缩减/压缩为(150，2)。
在 2D 可视化结果:
作者图片
从 2D 到 4D 的复苏
如果你只关心可视化，工作就完成了。但 PCA 作为一种压缩方案的好处在于，你可以使用主成分、、、投影、原始特征表示来恢复数据，并获得非常接近原始数据的近似值。
X_reduce具有 2D 的所有投影，我们可以通过简单地用pc2做矩阵乘法并加回平均值来获得恢复的数据。矩阵形状:(150，2) * (2，4)––>(150，4)。
作者图片
我们可以查看X_reduce中的一行，即一次一个示例，这样可以更清楚地看到矢量变换。Cu是基准u上的坐标，Cv在v上。
作者图片
这就是我们如何从 2D 恢复 4D 数据——通过使用 2D 投影乘以 4D 主成分。最后，别忘了加回均值。
现在让我们看看恢复的数据与原始数据的接近程度
作者图片
仅仅通过目测，我们就可以知道复苏做得相当不错。这就是为什么 PCA 也可以压缩图像的原因，因为图像与这里的矩阵没有太大的不同。
就是这样！通过这个极小的例子，我希望你在高层次上获得 PCA 背后的线性代数的感觉，并且知道将来什么时候使用它。如果你对寻找引擎盖下主要部件的过程感兴趣，网上有大量的资料。关键词是奇异值分解(SVD)。
同样，你不需要知道如何实现一个算法来使用它，这就是为什么很多库从我们这里抽象出细节。只要你理解基本的机制和直觉，作为一个调用库并且从未从头实现算法的 ML 实践者是没问题的。
反胃容易，消化难。
这里是我的一些其他文章，你可能会感兴趣
关注我并订阅我的电子邮件列表以获取新文章的更新。
迭代数据时速度提升 300 倍？是的，请！
当你必须浏览大量数据时，如何让自己的速度提高 300 倍(使用 Numba！)
回溯测试面临的挑战之一是必须遍历行。与矢量化成为可能并带来显著速度提升的其他操作不同，回溯测试时会受到限制，因为通常需要前一行的值来计算下一行。这迫使你不得不迭代数据，正如我们所知，这是非常缓慢的。
最近，我需要对一个包含大约 15 年期权数据的数据集进行迭代。诚然，这不是我见过的最大的数据集，但它仍然是一个相当大的数据集。因此，我决定探索和比较三种不同的方法来遍历它
TL；博士；医生
数字巴是地球上最伟大的发明。如果您可以使用数组和 numpy 来执行迭代，请使用 numba。
准备数据
这里真的没什么可看的——只是通过移除美元符号并将所有内容转换为浮点数来稍微清理一下数据。
我们要测试的主要内容是迭代数据框架以及平仓和开仓交易，计算 PnL 和账户规模的变化。账户大小将决定下一笔交易的手数，因此矢量化是不可能的，因为每笔后续交易的 PnL 取决于手数，而手数又取决于前一笔交易中账户大小的变化。
方法一:Itertuples
对 StackExchange 的粗略搜索表明,“itertuples”是当人们询问有关遍历数据帧的问题时通常会出现的方法。这比“iterrows”更快，因为在底层，pandas 将每一行转换成一个元组，而不是 pandas 系列，这使得访问数据更快。我还使用了我在某处读到的一个技巧，即设置“name=None ”,以便创建未命名的元组(这已被证明可以提高速度)。
方法 2:循环数组
这里，我们去掉了笨重的熊猫数据帧，代之以使用 numpy 数组。不幸的是，由于我需要回测的方式，矢量化不是一个选项，也没有任何我可以使用的 numpy ufuncs。好的老的循环必须做。
方法三:数字巴
最后，我决定在前面的循环数组中添加 numba。Numba 通过将某些 Python 和 Numpy 代码翻译成机器码(！！)在运行时。这使得它能够实现更高的速度。作为一个额外的奖励，它使用起来非常简单——只需安装@ numba.jit装饰器，就可以开始了！
测试时间
为了使用我的 array 和 Numba 函数，我必须将我的 dataframe 转换成一个数组。
然后，我对每个函数都运行了一次“计时”。注意，我只对非 numba 函数运行了 100 次循环，因为 1000 次循环花费的时间太长了…
鉴于三个测试的单位完全不同，结果非常清楚。这里有一些显示原始速度的图表(我知道这是一个非常糟糕的图表)
按作者分类的图表
一个更清晰的图表显示了使用 Numba 获得的速度提升
按作者分类的图表
结论
Numba 似乎将竞争对手打得落花流水——因此，当需要在不能向量化的回溯测试环境中迭代数据帧时，使用 numpy 数组，然后加入“ @numba .jit”装饰器，您将会在这些迭代中取得突破。
回答“这需要多长时间？”的 4 步流程
如何解决这个共同的利益相关者问题
作为数据科学家或数据分析师，利益相关者会问你一个常见的问题:“这需要多长时间？”当我第一次成为数据科学家时，我发现这个问题很难回答。如果我说我花了一个月的时间来构建一个模型，但是我不能交付，这会伤害我的涉众对我能力的看法吗？如果我更快地构建模型，我的涉众会认为我倾向于高估吗？如果你发现自己像我一样难以提供更好的时间估计，试试这个我开发的帮助我提供更准确时间表的 4 步过程。
1.确定项目范围
与风险承担者召开会议，确定项目范围和预期的可交付成果。确定项目干系人想要解决的业务目标和问题。
例如，市场营销要求您建立一个模型来预测客户流失。根据模型的使用方式，项目的范围会有很大的不同。如果营销计划向可能流失的客户发送电子邮件，那么这意味着如果没有数据工程师的帮助，您将需要更多时间在建立模型后将模型投入生产。如果营销只是想知道预测客户流失可能性的首要因素，那么这将是一个不需要投入生产的特别模型。
2.确认数据可用性
确定项目范围后，确认完成项目所需的数据可用。此外，检查是否有足够的历史数据来建立一个有意义的模型或进行详细的分析。
如果您需要将新数据引入数据仓库，请安排额外的时间来完成这项工作。如果您需要数据工程师或其他团队的帮助，请确保将此作为项目完成的一个依赖项。
3.列出项目任务
为项目创建一个高级任务列表，并估计完成每个任务所需的时间。例如，要构建客户流失模型，任务示例可以是:
- 探索性数据分析
- 数据准备和特征工程
- 模型开发
- 模型调整
- 总结模型结果以供利益相关方签署
- 生产模型
把所有任务的时间加起来，你就会对完成项目所需的时间有一个初步的估计。
4.应用蒙混因素
当您处理一个项目时，总会有一些您没有预算时间的意外事件—更长的数据准备、模型运行时间或模型调整。你可能需要其他团队的帮助，这会增加项目时间。考虑到这些不可预见的情况，应用一个蒙混因素。蒙混因素还应该考虑到你通常花在会议和回答问题上的时间，这些时间会占用你在项目上的时间。
使用过去项目的估计和实际完成时间来计算出你的蒙混因素。如果你估计 20 天，但实际上花了 30 天，那么你的蒙混因素是 30 除以 20 或 1.5。如果您在步骤 3 中估计当前项目需要 25 天，则用 25 乘以 1.5，给出 38 天(或大约 7.5 周)作为完成项目的估计时间。
最后的想法
无论您是数据科学家还是数据分析师，被问到“这需要多长时间”并不是一个很难回答的问题。
概括来说，使用以下 4 个步骤:
- 确定项目范围。
- 确认项目所需的数据可用性。
- 定义高级任务，并计算每项任务的预计时间。
- 对步骤 3 的总数应用一个模糊系数，以考虑意外事件、会议时间和回答问题。
你可能也会喜欢…
深度学习项目的 5 分钟生产就绪设置
忘掉所有配置 GPU 的头疼事吧
无论你使用什么深度学习库或框架，都不再重要。您将能够在短短 5 分钟和几行代码内设置好它。
https://unsplash.com/photos/7nsqPSnYCoY
为你的深度学习项目建立一个良好的环境并不是一件容易的事情。
您有太多的事情需要处理:库必须匹配特定的版本，整个环境需要可复制到其他机器，所有的东西都需要能够与您拥有的机器中的所有驱动程序通信。这意味着您需要为您的 NVIDIA GPU 安装特定的驱动程序，这是一个 CUDA 库，必须与您的驱动程序和您想要使用的框架兼容。
“好吧，但是来吧，你只需要做一次就行了，对吧？” 没有比这更远离事实的了。库发展如此之快，以至于你可能需要最新的能力。所以你需要更新一切。
你可以用 Anaconda 来管理一切，对吗？嗯，也许吧。
这里你的纸牌屋肯定会倒塌。你可以用 Anaconda 来管理一切，对吗？嗯，也许吧。Anaconda 为您做了很多事情，很难在不影响整个环境的情况下改变【只是一件小事】。
但是，如果您的软件包不适用于您的平台、操作系统，或者您只需要一个不存在的版本，该怎么办呢？您将使用快速 pip 命令手动添加它。
嘣！你搞砸了一切，你需要从头开始(或者从你最近的备份)重建一切。
好吧，是时候从这个噩梦中走出来了。
欢迎来到英伟达 NGC。
随着容器彻底改变了软件开发的世界，它们现在可以帮助数据科学家构建更健壮的环境。
有一点是肯定的:数据科学可以从软件开发世界中学到一些东西。
嘣！你搞砸了一切，你需要从头开始(或者从你最近的备份)重建一切。
NGC 是软件中心，提供 GPU 优化框架、预训练模型和工具包，以在生产中训练和部署人工智能。它是一个容器注册表，包含训练模型所需的所有工具:不管您使用的是 Caffe2、Pytorch、Tensorflow、Keras、Julia 还是其他工具。
在 NGC 目录中有成吨的生产准备好的容器，你只需要选择你的。
英伟达 NGC 不仅是一个容器注册表，它内置了许多功能，可以帮助您的组织将模型投入生产。查看 NVIDIA 的文档页面了解更多信息。
我们应该从什么开始？
先说一台配有 GPU 的 Linux 机器(如果要训练模型，GPU 不是强制性的但是强烈推荐)。我在 Ubuntu 20.04 LTS 版和 18.04 LTS 版上进行了测试，但可以很容易地适应其他 Linux 发行版或 Windows 机器。
注意 : 你没有 GPU 还是你只是不想搞乱你的系统？
只需注册 Oracle Cloud 的免费试用版。您将获得 300 美元的积分，并且可以使用 GPU(只要确保您选择了一个可以使用 GPU 的家庭区域)。
点击此处了解更多关于 GPU 地区的信息。如果您注册，您还可以访问 Oracle 永不过期的免费云资源！你可以用这些资源做很多事情，如果你想要一些想法请查看我写的关于这个的文章！
我们需要做什么？
步骤很简单，我们只需要安装 NVIDIA 驱动程序和 Docker。然后我们下载想要的 docker 镜像，开始工作！
步骤 1:在 Ubuntu 20.04 上安装 NVIDIA 驱动程序
注意:如果你使用的是另一个 Ubuntu 版本，请确保相应地修改脚本。此外，如果您启用了安全引导，这种方法将不起作用。
在 Ubuntu 20.04 上安装最新的 NVIDIA 驱动程序
要验证安装，使用命令 nvidia-smi 。您应该会看到类似这样的内容。
第二步:在 Ubuntu 20.04 上安装 Docker
注: 没有 sudo 权限 的情况下使用 docker 命令 需要注销并登录。
第三步:是时候让 Docker 与 NVIDIA 驱动程序进行通信了
在 Docker 19.03 或更高版本上启用原生 GPU 支持。
我们现在想测试 Docker 是否能够与 NVIDIA 驱动程序通信。要做到这一点，只需运行下面的命令，您应该会看到与第 1 步类似的内容。
注意:我在不同的云提供商上进行了试验，根据操作系统、虚拟机类型和 GPU，此时可能需要重启。因此，如果你得到一个错误，只需尝试 sudo 重启并再次执行上述命令。现在，您应该可以看到第 1 点的 tipycal nvidia-smi 结果。
第四步:让我们拉图像并运行它！
注 :标志—shm-size = 1g—ulimit memlock =-1—ulimit stack = 67108864是必要的，以避免操作系统限制资源分配给 Docker 容器。
我们现在进入容器，让我们看看是否一切正常。
python
导入张量流
从图中可以看出，GPU 可用，tensorflow 可以使用。
可选:访问环境
当你从机器上断开时，你会注意到你不再在集装箱里了。
要再次连接，您需要使用 docker ps 找到正在运行的容器的容器 _ id ，然后:
docker exec-it
最终考虑
在本教程中，我们发现使用英伟达 NGC 的映像，使用您需要的所有库和工具来创建生产就绪环境是多么容易。
我们看到了配置 Docker 使其与 NVIDIA 驱动程序和您需要的框架通信是多么容易。
我们在 5 分钟、内完成了所有这些，没有头痛。
你需要一个永远免费的云环境来测试你的想法或者支持你的项目吗？ 查看 Oracle 云永不过时层 ！
我是 Roberto Di Bella，甲骨文公司的数据科学家顾问。帮助数据科学家、开发人员和公司在 Oracle 云上取得成功。
随时连接上LinkedIn。
为准备使用 Python 学习数据科学的人提供的 5 步指南
Python 击败 R、Excel、Tableau 学习数据科学。
大约一年半以前，当我想做一项普通的数据科学任务，而我最喜欢的语言 R 却不能胜任这项任务时，我学会了如何用 Python 编程。我想浏览一些网站，从我收集的数据中预测结果。(为了充分披露，我想知道在我的 Instagram 猫的标题中提问是否会产生更多评论。确实如此。)
正如我所发现的，你可以非常容易地用 Python 学习数据科学，因为它有全面的库和包。它可以处理机器学习、大数据挖掘、预测、自然语言处理以及任何你可以想象数据科学家试图完成的事情。这就是我写这篇关于用 Python 学习数据科学的帖子的灵感。
这篇文章将假设你是一个读者:第一，你想学习数据科学。这是一个伟大的职业——如果你喜欢满足好奇心和研究模式，这是一个很好的乐趣，有经济回报，并受到许多著名的数据科学公司的追捧。这不仅仅是十年来最热门的工作——这是一个让你问出让你夜不能寐的问题，并给出有趣答案的职业。我认为我们很多人都有天生的好奇心，我们希望看到它得到满足。
我还假设你懂一些 Python。你不需要成为一名专家，但是如果你想学习 Python 的数据科学，从了解一些 Python 开始会很有帮助。你不需要成为一名专业人士——我设法用一点 Python 知识完成了我的任务——但是知道如何操作终端是必须的。幸运的是，Python 社区是健壮的、有用的，并且充满了教程、解释和老手。
最后，我假设你正在寻找一个路线图:通过学习 Python 知识，帮助你在数据科学领域找到工作的东西。Python 是学习数据科学的一种很好的语言，因为它的许多优势，如创建简单的可视化、机器学习和数据挖掘，都被数据科学家用于日常工作中。
如果你符合所有这些假设，这是你的职位。本文将指导您学习如何使用 Python 学习数据科学，最终目标是成为一名数据科学家。
1.你需要了解数据科学到底是什么
这似乎是一个奇怪的起点，但当我第一次开始学习 Python 时，我对数据科学一无所知。如果当时我必须给自己定义数据科学，我会说像制作图表一样。我不会错，但这也不是全部真相。我甚至不知道我正在用 Python 学习数据科学，因为我永远也不会想到做出预测是数据科学的一部分。
数据科学在维基百科中的定义是“统一统计学、数据分析、信息学及其相关方法的概念，以便用数据理解和分析实际现象。”简单来说，就是用统计学的方法去理解趋势。
数据科学并不特定于 Python 或任何其他语言。除了一支铅笔、一些纸和一个像样的计算器(或者上帝禁止 Excel)，你可能什么都不用带就能完成所有的数据科学任务。如果你知道什么是数据科学，你就知道 Python 不是必需品，而是一条方便的捷径，可以让你灵活、快速、有效地完成所有工作。
为了更好地了解什么是数据科学，用更实际的术语而不是模糊的定义来思考它会有所帮助。StrataScratch 有一个很好的指南，它将你在数据科学面试中会被问到的问题的类型进行了细分，它提供了数据科学家每天所做的各种专业任务的整体视图。
有了这些知识，维基百科提供的定义就更有意义了。专业意义上的数据科学可以描述为使用统计模型、客户数据、概率和预测等工具来理解数字，从而帮助企业做出决策的方法。数字进来，数据科学发生，决策出来。
2.你需要知道你不知道的
Python 技能和数据科学技能的维恩图绝对不是一个圆。
一旦你知道什么是实用的数据科学，第二步就是用 Python 描绘出你现有的知识。Python 技能和典型的数据科学家工作要求有相当大的重叠，因此您可能会发现，当您学习典型的数据科学家技能时，您可能已经知道如何使用 Python 完成这些工作。然而，你不太可能做到这一切。
比如我知道怎么用 TensorFlow 做神经网络建模吗？肯定不是。但那是包含在“数据科学”类别中的。如果我想用 Python 学习数据科学，我会把它算在我的一堆弱点中，并专注于学习这个和其他数据科学技能。
问问你自己:目前你能用 Python 做什么？你还擅长什么？我推荐的最好方法是查看一些典型的基于 Python 的数据科学家工作面试问题库，比如这些数据科学 Python 问题。从那里，你可以很容易地规划出你的专业领域，并复习数据科学工作中可能出现的内容。
例如，你可能会发现，虽然你已经真正掌握了使用“熊猫”包计算差异并输出数字，但你还需要多练习一下使用 Python 开发预测。
一旦你对自己的优势和劣势有了更好的了解，你就能更好地准备用 Python 学习数据科学。
3.做有趣的基于 Python 的数据科学项目
所以现在你知道你不知道的了。第三步，打磨那些生疏的技能，学习新的。最好的方法是找到一个有激情的项目。
我用 Python 学习了数据科学，因为我痴迷于理解我的猫的 Instagram 帐户中的趋势。这种天生的好奇心驱使我学习如何收集数据，将数据转换成可解析的格式，分析数据，并输出结果。如果我一直试图为学校做这件事，我会在第一个障碍就放弃，或者只是复制粘贴代码而没有任何真正的理解。
虽然 Python 对于初学者来说是一门很棒的语言，但是如果你带着理解和领悟的热情来学习 Python，而不是仅仅记忆命令和粘贴代码，那么用 Python 学习数据科学会容易得多。
回到你的强项和弱项列表，找到你还在努力的地方。你有什么迫切的问题？你想知道天气如何影响你的跑步时间吗？你想知道为什么你家附近有这么多花栗鼠吗？你想探究鸟类大小和它们灭绝的可能性之间的关系吗？(以上都是个人例子，怕你说不清。)
看看网上的一些项目来获得灵感。例如，如果你想找到一些受机器学习启发的项目， Confetti 充满了有用的例子。如果你可以确定你的动机，那么你和你渴望找到的问题的答案之间的唯一障碍就是你缺乏技能，那么用 Python 学习数据科学将不会造成任何障碍。你会很快受到启发，用 python 学习数据科学，并回答那些恼人的问题。
用 Python 进行这些类型的数据项目会让你很好地掌握各种统计方法、数据即图表，以及你在学习 Python 数据科学的过程中会遇到的问题。
4.寻找入门级数据科学工作中提到的技能
如果你正在学习 Python 数据科学，你可能不会马上投入到一份六位数的数据科学工作中。没关系！随着数据科学技能的高需求，你不需要一个学位就能得到一份数据科学的工作。你只是需要经验。
考虑到这一点，查看这些大数据科学职位的职位描述是没有意义的，因为对你来说，用 Python 学习数据科学到那种程度是不现实的。要开始朝着梦想中的数据科学工作努力，你应该看看业务分析师和数据分析师的职位描述，这与数据科学家有一些重叠。初级数据科学家也是很好的工作角色。
类似于列出你不知道的，写一份你目前不能处理的所有工作要求的清单。这将让您了解开始数据科学职业生涯所需的实用技能。然后，寻找使用 Python 完成这些任务的方法。
例如， Booz Allen Hamilton 要求他们的初级数据科学家拥有 NLP 经验。一次快速的谷歌搜索把我带到了这篇文章，在那里 Eric Kleppen 将三个简单的项目放在一起，用 Python 学习 NLP。你关注的具体工作越多，你对入门级数据科学工作中最常见和最受欢迎的技能的了解就越多。
一旦你设置并完成了其中的几个项目，你就已经 95%地学会了使用 Python 学习数据科学。你会知道什么是数据科学，什么是你需要关注的，什么好玩的项目可以帮助你学到你还不具备的技能，甚至什么是入门级的工作在找。最后一步就是坚持学习。
5.保持好奇
通过像素成像
学习数据科学永远不会真正结束，无论是 Python 还是任何其他语言。想想数据科学家的职业道路在十年前几乎不存在，你就会明白事情变化有多快。与任何语言一样，Python 中不断出现新的包、项目和概念。为了保持最新的、可雇佣的、知情的状态，确保你带着激情和好奇心去接近这些发展。
在你的数据科学家职业道路的每一步，你都可以重复步骤 1-4，随着职业道路以及随之而来的技能和要求的发展，你可能会得到略有不同的答案。当你准备好获得下一份工作时，重新审视你知识上的差距。当你考虑去谷歌找一份数据科学家的工作时，确保你知道他们会要求你证明什么技能。最重要的是，保持好奇心。继续提问。带着热情和兴趣接近自己的无知。这就是你如何通过使用 Python 继续学习数据科学的方法。
关于如何用 Python 学习数据科学的最终想法
本文面向那些了解一些 Python，认为自己可能喜欢数据科学方面的工作，并且想知道如何依靠现有的 Python 来学习数据科学的人。Python 是学习数据科学的最佳编码语言，易于初学者掌握，也易于初学者改进。
总的来说，学习 Python 数据科学的最佳方式就是:
- 对数据科学到底是什么有一个最新的理解
- 找出您现有的 Python 知识和知识差距
- 挑选出能让你保持兴趣的 Python 项目
- 了解入门级数据科学工作需要的技能
- 对数据科学和作为编码语言的 Python 保持好奇。两者都经常变化。
有了它，你将踏上学习 Python 数据科学的道路，并获得你梦想中的数据科学家的工作。
A/B/C 测试:如何分析多组实验的结果
方差分析的解释(ANOVA)
图片来自 Pixabay
在科技初创公司中，实验被广泛用于决定是否推出新产品功能、用户界面设计变化、营销活动等，通常目标是提高转化率、收入和/或销量。通常，我们想要测试一个改变(治疗组)对现状(对照组)的影响，但是如果我们正在考虑几个选项，并且想要对两个以上的组进行实验呢？
在本文中，我将介绍单向方差分析背后的直觉，以及如何使用它来分析您在多组实验中的结果。
为什么你不应该做多重 t 检验
你可能想知道在你的实验中是否可以使用 t 检验来比较各组之间的差异。简短的回答是不，你不应该这样做！不仅会变得乏味，而且如果您使用 t-test 来比较许多对，您犯 I 型错误(假阳性)的几率会增加。
为了说明这一点，考虑一个有 5 个不同组的实验。在这种情况下，我们需要运行的 t 测试的数量是5 Choose 2 = 10 个 t 测试！如果我们进行这 10 次 t 检验，即使我们将每个 t 检验的显著性水平设为 0.05，I 型错误的概率也不再是 5%。
相反，类型 I 错误的概率增加到1 — (1 — 0.05) ^ 10 = 0.40，因为我们正在进行十次比较，并且在所有测试中没有获得任何显著结果的概率现在是0.95 ^ 10 = 0.60。这意味着，如果我们做 10 次 t 检验来比较实验中 5 组之间的平均值，我们最终会在 40%的时间里错误地拒绝零假设，而不是在 5%的时间里！
关于 ANOVA
ANOVA 代表方差分析，是对两组或多组平均值之间差异的统计显著性的检验。本质上，它将数据中的总方差划分为不同的类别，允许我们比较组的平均值之间的变化量和每组内的单个观察值之间的变化量。
假设
在进行 ANOVA 检验之前，我们需要确保满足以下三个假设:
1。我们从中抽取样本的基础人群是正态分布的。检查的一种方法是绘制观察值的直方图，以直观显示分布是否呈正态分布。
2.样本所来自的总体的方差相等。我们可以用箱线图检查这一点，看看观察值的方差是否相等。
3.每组中的观测值是相互独立的，每组内的观测值是随机抽样的。我们需要确保实验是精心设计的，以保证组间的独立性和组内的随机抽样。
假设检验
在这一节中，我将介绍计算检验统计量和进行假设检验所需的步骤。在单因素方差分析中，零假设是所有组的平均值相等，而另一个假设是至少有一个平均值不同。
R 和 Python 中有许多计算器在线和统计软件包，您可以使用它们来执行计算，但是以下步骤中的细节旨在帮助您理解方法和概念。如果公式看起来很吓人，不要担心，相反更重要的是理解每一步的直觉！
- 计算平方和
在简单的方差分析中，我们可以将总平方和(SS_T)视为组内平方和(SS_w)和组间平方和(SS_B)之和:
组内平方和(SS_w)代表组内可变性的数量，但不受组间总体差异的影响。组内平方和等于一个组内所有观察值与其组均值的偏差平方和，即所有组的总和。
组间平方和(SS_B)可视为组间差异，但不受组内变异量的影响。它可以计算为总体大平均值的组平均值之间的平方和。
2。计算自由度
接下来，我们需要计算自由度。类似于平方和，总自由度等于组内自由度(df_w)和组间自由度(df_B)之和:
组内自由度(df_w)是观察数-组数，而组间自由度(df_B)是组数- 1。
3。计算均方值
为了能够比较平方和，我们将它们除以相关的自由度(df)以获得均方值。
4。计算 F 统计量
检验(F)统计量是组间均方(MS_B)与组内均方(MS_w)的比值
5。求 F 的临界值
对于α、组内自由度(N - k)和组间自由度(k - 1)的相应值，从 F 分布表中确定 F 的临界值。
6。方差分析测试的结论
如果从你的实验中得到的 F (F_obt)值大于 F (F_crit)的临界值，我们可以拒绝均值之间没有差异的零假设。这意味着至少一个平均值在统计学上显著不同于一个或多个其他平均值。
比较成对平均值:谢弗法
能够拒绝方差分析检验的零假设告诉我们至少有一个均值是显著不同的，但是我们如何知道哪个均值是不同的呢？
回想一下我们上面进行多重 t 检验的例子，这将导致 I 型错误的增加。然而，如果我们能够使用 ANOVA 拒绝均值无差异的零假设，我们可以使用事后分析的 Scheffé方法来比较任何一对均值，而不用担心增加 I 型误差。
我们可以使用 Scheffé方法计算一个称为 C 的统计量。计算从我们的实验中获得的 C 的公式是:
其中，x̄₁和 x̄₂是被比较的两组的平均值，N₁和 N₂是这两组中的观察次数，MS_w 是来自方差分析的组内均方值。
然后，我们可以将从我们的观察中获得的 C 值与 C 的临界值进行比较。C 的临界值可以从以下公式中找到:
其中 K 是组的数量，F_crit 是 F 的临界值，您可以从 F 分布表中查找相应的自由度和显著性水平。
如果得到的 C 值大于 C 的临界值，可以拒绝均值对相等的零假设。
关联强度:ω平方
来自 ANOVA 的检验统计可以告诉我们组间均值的差异是否具有统计学意义，但不能告诉我们效果大小。为了确定治疗效果的强度，我们可以使用下面的公式来计算ω平方(ω2):
其中，SS_B 为组间平方和，K 为组数，MS_w 为组内均方，SS_T 为平方和。
ω平方(ω2)告诉我们治疗效果可以解释多少总可变性，可以取-1 到+1 之间的任何值，0 表示没有任何影响。
结论
我希望这篇文章能帮助你更好地理解什么是方差分析，以及如何用它来解释多变量实验的结果。以下是一些关键要点:
- ANOVA 是对两组或多组平均值之间差异的统计显著性的检验。
- 如果您能够使用 ANOVA 拒绝均值无差异的零假设，您可以使用事后分析的 Scheffé方法来比较任何一对均值，而不用担心增加 I 型误差。
- 为了确定治疗效果的关联强度，您可以计算ω平方(ω2)，这可以告诉您治疗效果可以解释多少总可变性。
实验需要时间和资源来设计、设置和部署到生产中。希望这有助于您将测试工具包扩展到多元实验中！
A/B 测试:统计测试完全指南
入门
对于营销人员和数据科学家来说，建立正确的测试至关重要。
约翰·麦克阿瑟在 Unsplash 上的照片
什么是 A/B 测试？
A/B 测试是用来优化网络营销策略的最流行的控制实验之一。它允许决策者通过查看从两个可能的选项 A 和 b 获得的分析结果来选择网站的最佳设计。
在本文中，我们将看到如何使用不同的统计方法来使 A/B 测试成功。我推荐你也看一下 这本笔记本 你可以在那里玩本文讨论的例子。
为了理解 A/B 测试是关于什么的，让我们考虑两个可选择的设计:A 和 B。一个网站的访问者被随机提供两个中的一个。然后，通过网络分析收集关于他们活动的数据。给定这些数据，可以应用统计测试来确定两种设计中的一种是否具有更好的功效。
现在，不同种类的指标可以用来衡量一个网站的功效。对于离散度量，也称为二项式度量，只有两个值 0 和 1 是可能的。以下是流行的离散指标的例子。
离散指标:点击率(作者图片)
使用连续度量，也称为非二项式度量，度量可以采用连续值，而不限于一组两个离散状态。以下是流行的连续指标的例子。
连续指标:平均订单值(作者图片)
我们将详细了解离散和连续指标如何需要不同的统计测试。但首先，让我们快速回顾一下统计学的一些基本概念。
统计显著性
利用我们从网站用户活动中收集的数据，我们可以比较两种设计 A 和 b 的功效。简单地比较平均值没有多大意义，因为我们无法评估我们观察结果的统计显著性。确定两个样本之间观察到的差异源于偶然的可能性确实是至关重要的。
为此，我们将使用双样本假设检验。我们的零假设 H0 是两个设计 A 和 B 具有相同的功效，即它们产生了相等的点击率，或每用户平均收入等。然后通过 p 值测量统计显著性，即观察到样本间差异至少与我们实际观察到的差异一样大的概率。
p 值(图片由作者提供)
现在，必须小心谨慎地正确选择替代假设 Ha 。该选择对应于单尾和双尾测试之间的选择。
在我们的情况下，双尾检验更可取，因为我们没有理由先验地知道 A 和 B 的结果之间的差异是有利于 A 还是 B。这意味着我们考虑另一个假设HaA 和 B 具有不同功效的假设。
单尾和双尾测试(图片由作者提供)
因此， p 值被计算为所有x’s . t .p(x’)<= p(我们的观察)上所选检验统计量的概率密度函数 p(x) 的两个尾部下的面积。这种 p 值的计算显然取决于数据分布。因此，我们将首先了解如何针对离散指标计算它，然后针对连续指标计算它。
离散度量
让我们首先考虑一个离散的指标，比如点击率。我们随机向访问者展示两种可能的广告设计中的一种，并记录有多少人点击了它。
假设我们收集了以下信息。
- nX = 15 访客看到了广告 A，其中 7 人点击了它。
- nY = 19 访客看到了广告 B，其中 15 人点击了它。
点击率:列联表(图片由作者提供)
乍一看，版本 B 似乎更有效，但是这种差异在统计学上有多大意义呢？
费希尔精确试验
使用上面显示的 2x2 列联表，我们可以使用 Fisher 精确检验来计算精确的 p 值并检验我们的假设。为了理解这个测试是如何工作的，让我们首先注意到，如果我们固定表格的边距(即每行和每列的四个和)，那么只有少数几种不同的结果是可能的。
点击率:可能的结果(作者图片)
现在，关键的观察是，在零假设 H0 下，A 和 B 具有相同的功效，观察到这些可能结果的概率由超几何分布给出。
可能结果的超几何分布(作者图片)
使用这个公式，我们得到:
- 看到我们实际观测的概率是 ~4.5%
- 如果 B 为 ~1.0% (左尾)，则看到更多不太可能的有利观测的概率；
- 如果 A 为 ~2.0% (右尾)，则看到更不可能的观察结果的概率为赞成。
点击率:尾部和 p 值(作者图片)
所以费雪精确检验给出 p 值≈ 7.5% 。
皮尔逊卡方检验
费希尔精确检验具有计算精确 p 值的重要优势。但是，如果我们有一个大的样本量，它可能是计算效率低下。在这种情况下，我们可以使用皮尔逊卡方检验来计算一个近似的 p 值。
让我们将列联表第 i 行和第 j 列的观测值称为 Oij 。在行列独立性的零假设下，即假设 A 和 B 具有相同的功效，我们可以很容易地计算出相应的期望值 Eij 。此外，如果观察值呈正态分布，那么χ2 统计量恰好遵循具有 1 个自由度的卡方分布。
皮尔逊卡方检验(图片由作者提供)
事实上，由于中心极限定理，如果样本量足够大，该检验也可以用于非正态观测值。
在我们的例子中，使用皮尔逊卡方检验，我们得到 χ2 ≈ 3.825 ，这给出了 p 值≈ 5.1% 。
连续指标
现在让我们考虑一个连续指标的情况，比如每个用户的平均收入。我们随机向访问者展示我们网站的两种可能布局中的一种，并根据每个用户一个月产生的收入，我们希望确定两种布局中的一种是否更有效。
让我们考虑下面的情况。
- nX = 17 用户看到了布局 A，然后进行了以下购买:200 美元，150 美元，250 美元，350 美元，150 美元，350 美元，250 美元，150 美元，250 美元，150 美元，150 美元，150 美元，200 美元，0 美元，100 美元，50 美元。
- nX = 14 用户看到了布局 B，然后进行了以下购买:300 美元，150 美元，150 美元，400 美元，250 美元，250 美元，150 美元，200 美元，250 美元，150 美元，300 美元，200 美元，250 美元，200 美元。
每个用户的平均收入:样本分布(作者图片)
同样，乍一看，版本 B 似乎更有效。但是这种差异在统计学上有多大意义呢？
z 检验
Z 测试可在以下假设条件下应用。
- 观察值呈正态分布(或样本量较大)。
- 采样分布具有已知的方差 σX 和 σY 。
在上述假设下，Z 测试利用了以下事实:下面的 Z 统计量具有标准正态分布。
z 测试(图片由作者提供)
不幸的是，在大多数实际应用中，标准偏差是未知的，必须进行估计，因此 t 检验是更可取的，我们将在后面看到。无论如何，如果我们知道 σX=100 和 σX=90 的真实值，那么我们将得到 z ≈ -1.697 ，这对应于一个 p 值≈ 9% 。
“学生”t 检验
在大多数情况下，抽样分布的方差是未知的，所以我们需要估计它们。学生的 t 检验可以在以下假设下应用。
- 观察值呈正态分布(或样本量较大)。
- 采样分布具有“相似”的方差 σX ≈ σY 。
在上述假设下，Student 的 t 检验依赖于以下观察结果:下面的 t 统计量具有 Student 的 t 分布。
“学生”t 检验
这里 SP 是从样本方差 SX 和 S Y 中获得的合并标准差，它们是使用应用贝塞尔修正的无偏公式计算的。
在我们的示例中，使用学生的 t-检验，我们得到了 t ≈ -1.789 和 ν = 29 ，这给出了 p 值≈ 8.4% 。
韦尔奇 t 检验
在大多数情况下，学生的 t 检验可以有效地应用于良好的结果。然而，很少会违反第二个假设(抽样分布的相似方差)。在这种情况下，我们不能计算混合方差，我们应该使用韦尔奇的 t 检验，而不是学生的 t 检验。
该测试在学生 t-测试的相同假设下进行，但取消了对相似方差的要求。然后，我们可以使用一个稍微不同的 t 统计量，它也有一个学生的 t 分布，但是具有不同的自由度数量 ν 。
韦尔奇 t 检验
ν 的复杂公式来自韦尔奇-萨特思韦特方程。
在我们的例子中，使用 Welch 的 t 检验，我们得到了 t ≈ -1.848 和 ν ≈ 28.51 ，这给出了 p 值≈ 7.5% 。
连续非正态度量
在前面关于连续度量的部分中，我们假设我们的观察值来自正态分布。但是在处理每个用户的月收入时，非正态分布是非常普遍的。常态经常在几个方面被破坏:
- 零膨胀分布 —大多数用户根本不买任何东西，所以有很多零观察值；
- 多式联运分销 —一个细分市场倾向于购买便宜的产品，而另一个细分市场购买更贵的产品。
连续非正态分布(图片由作者提供)
然而，如果我们有足够的样本，在正态假设下导出的检验，如 Z 检验、Student’s t 检验和 Welch’s t 检验，仍然可以应用于显著偏离正态的观察值。事实上，由于中心极限定理，随着样本量的增加，检验统计量的分布趋于正态。在我们正在考虑的零膨胀和多峰的例子中，即使是 40 的样本大小也会产生一个非常接近正态分布的分布。
非正态分布的正态收敛(图片由作者提供)
但是，如果样本量仍然太小，无法假设正态性，我们没有其他选择，只能使用非参数方法，如曼-惠特尼 U 检验。
曼恩-惠特尼 U 检验
该检验没有对抽样分布的性质做出假设，因此它是完全非参数的。曼-惠特尼 U 检验的思想是计算下面的 U 统计量。
曼-惠特尼 U 检验(图片由作者提供)
该检验统计量的值被制成表格，因为分布可以在零假设下计算，即对于来自两个总体的随机样本 X 和 Y ，概率 P(X < Y) 与 P(X > Y) 相同。
在我们的例子中，使用曼-惠特尼 U 检验，我们得到 u = 76 ，这给出 p 值≈ 8.0% 。
结论
在本文中，我们已经看到不同种类的度量、样本大小和抽样分布需要不同种类的统计测试来计算 A/B 测试的显著性。我们可以用决策树的形式总结所有这些可能性。
用于 A/B 测试的统计测试摘要(图片由作者提供)
如果你想了解更多，你可以从玩 这个笔记本 开始，在那里你可以看到本文讨论的所有例子！
A/B 测试数据科学面试问题指南
如何以一种让你脱颖而出的方式回答 A/B 测试数据科学面试问题
A/B 测试是许多数据科学面试的主要内容，尤其是当角色决定如何最好地设计某种形式的用户体验时，通常是通过某种形式的应用程序或网站。想想亚马逊、优步和 Youtube——所有这些公司的应用程序都有不断变化的功能，每个变化的背后都有一个 A/B 测试，这是许多数据科学家的面包和黄油。
作者原创图片
只要在谷歌上快速搜索一下，你就会发现很多关于如何构建经典 A/B 测试答案的指南。这些指南可能相当有用，但它们不会让你的答案脱颖而出。这就是本文的内容:我将与您分享一两件(或三件)关于我如何在自己的数据科学面试经历中接受 A/B 测试问题的事情，以及我如何让我的答案给面试官留下额外的印象。我不会涉及制定假设和进行 t 检验的基础知识，但我会更加关注如何将你的答案与其他答案区分开来。
什么是 A/B 测试？
A/B 测试本质上是一个受控的实验，以做出关于产品发布的关键决策，这些变化可以从按钮的大小和颜色这样的小元素到应用程序上整个新页面这样的大变化。
变体
与只测试两个不同版本的 A/B 测试相反，A/B/N 测试涉及同时测试 N 个版本。A/B/N 测试通常用于大规模变更。
多变量测试发生在版本和相关变量的所有排列同时被测试的时候，并且经常在必须做出组合决策的时候使用，而不是在每个变化上运行 A/B 测试。
机会规模
对于许多受访者来说，他们会直接谈论样本大小、统计意义等。当被问到一个暗示 A/B 测试的问题时，他们不顾一切地卸下他们在准备面试时记忆的框架和答案。然而，这些答案并没有脱颖而出。
相反，不仅仅要考虑 A/B 测试的技术，还要考虑 A/B 测试进行的环境。A/B 测试在现实世界中的现实是，并不是所有提议的变更都值得测试，并且在任何公司中，当决定某个特定的 A/B 测试是否值得追求时，都有一个有限的元素需要时间和资源的明智分配。
当产品经理带着一个想法来到你这个数据科学家面前时，我们希望能够根据历史数据评估这个想法的潜在影响。这种形式的机会评估至关重要，因为它让您作为数据科学家的努力变得有价值。例如，考虑一个新的电子商务网站的变化，它将允许来自多个零售商的结帐。为了确定这个机会的大小，我们需要通过分析用户通常购买的不同商品的数量来获得一个上限。如果只有一小部分用户购买了大量的商品，这种 A/B 测试可能根本就不值得进行。因此，重要的是要估计实际上会改变行为的用户数量，以及这如何转化为大公司的实际数量。
更重要的是，要回答关于机会规模的问题，您需要绝对清楚您打算使用什么指标。概述你在面试中所做的确切假设，并坚定地表明这个机会的评估价值。
韵律学
度量，度量，度量。如果你不能全面而自信地谈论度量标准，那么任何关于 A/B 测试的答案都是不完整的。谈论指标的关键是要很好地了解公司的产品，并研究通常会使用哪种指标。例如，在我面试电子商务公司的经历中，你经常会被要求评估一个行动号召功能，比如一个提醒你某个优惠即将到期的弹出窗口。
如果您正在评估行动号召功能:
Stephen Phillips 许可在 Unsplash ( 链接 ) 上使用的图片
因此，关键是要很好地了解应用程序接口，并理解什么指标倾向于与它相关联。不要把所有可能的指标都塞进你的答案里。更重要的是，你绝不能停留在仅仅提及可能相关的度量标准。记住，一定要在上下文中回答！你必须告诉面试官为什么这个指标很重要，它对整体用户体验有什么影响。
你如何量化 Twitter 用户的影响力？
这里有一个关于指标的问题，实际上是在 Twitter 产品访谈中被问到的:
问题链接:https://platform . stratascratch . com/technical/2051-influencer-metrics
一些常见的答案可能是关注者数量、转发数量、喜欢和提及数量。如果你想给出一个更有力的答案，可以提到一些类似推特链接的点击率，或者固定时间跨度内的互动次数。对关注者数量的一个更精确的回答是提到实际上为特定用户打开通知的关注者的数量。根据我的经验，面试官不希望你列出所有你已经知道的可能答案。相反，面试官心中有一个理想的答案，你必须努力思考他或她可能会给你的线索。
作者原创图片
有很多方法可以得到一个全面的答案，但是有两个概念我一定要提到:转换漏斗和 ltv。转换漏斗描述了导致用户最终决策点的考虑和体验的各个阶段。术语“漏斗”用于说明沿着漏斗向下发生的自然损耗。始终将度量标准的选择放在一个漏斗的框架中，这将使您的答案听起来更加深思熟虑！如果你真的想了解转换漏斗的细节，看看这篇关于七种不同类型漏斗的文章。更好的是，使用终身价值(LTV)的概念来评估你的度量的长期观点。这告诉面试官，你考虑的不仅仅是一个特定设计决策的直接后果，还包括它如何影响用户的未来，以及它如何影响其他用户(外部性)。事实上，我希望你能更进一步，谈谈外部性是如何违反控制组和治疗组之间的独立性假设的，以及我们可能希望如何对此进行控制。
样本量
- 检验的功效(通常约为 0.8–0.9):当替代假设为真时，拒绝零假设的概率。考虑幂的另一种方式是 1 减去β，其中β是第二类错误的概率，对于那些更熟悉统计方法的人来说。
- 检验的显著性水平:错误地拒绝零假设的最大可能性，当它实际上为真或类型 1 错误时
- 最小期望效应
在 A/B 测试面试中谈论样本大小是没有商量余地的。一般来说，A/B 测试所需的样本量取决于三个因素:
MDE 是您愿意观察的基线上的最小改进。例如，如果我们关注观察到每花 10 美元购买就会增加 1 美元的效果，我们将 MDE 设置为 10%。
事实上，大多数准备充分的受访者不会错过在他们的答案中提到 MDE，但真正精彩的答案会更进一步。在现实世界中，更有效的方法是忘记精确地修复 MDE 相反，我们应该设定限制，以便更好地做出决策。例如，保持 MDE 为 5%不变，我们可以计算不同水平的基线需要多少样本。一般来说，基线越小，检测相同 MDE 所需的样本量越大。想一想，看看为什么直觉上这是对的。
p 值
什么是 p 值？样本大小如何影响 p 值？
这听起来像是一个相对简单的问题，但你会惊讶地发现，当被问到这个问题时，有多少受访者实际上答非所问！
以下是对这个问题的转述解释:https://platform.stratascratch.com/technical/2043-p-value
p 值是在零假设下找到观察结果的概率。如果您有更多的数据，那么观察结果的标准误差(不确定性)会降低(因为 SE=std/sqrt(N))，因此检验统计量会增加，因此我们可以更有信心拒绝零。此外，测试的统计能力(1-(当空值为假时拒绝空值失败的概率)会增加。现在，这些信息可以使你的假设检验更强(效应大小)，但它与我们对 p 值的解释无关。
这是另一种思考方式。p 值是从 0 到 1 的数，其提供了所获得的测试结果的统计显著性水平的指示，与仅仅由于随机性而获得的测试结果相反。具体来说，p 值衡量在假设零假设为真的情况下获得测试结果的可能性。通常，高于 0.05 的 p 值是令人信服的证据，表明我们不能拒绝无效的零假设。
当我们进行 A/B/N 测试时，事情变得稍微复杂一些，这就是你在统计课上学到的知识派上用场的地方。例如，如果我们有 4 个治疗组和一个对照组，观察到至少 1 个假阳性的概率是多少？(类型 1 错误)[提示:不是 0.05 * 4]
答案如下:
pr(FP = 0)= 0.95 * 0.95 * 0.95 * 0.95 = 0.8145
因此，
pr(FP > = 1)= 1–0.8145 = 0.1854(18.54%，而不是 20%)
干扰
最后，我们来谈谈干扰，也就是说当治疗组和对照组之间的独立性假设被违反时。在 A/B 测试的世界里，一切都是理想的，因为除了治疗变量之外的一切都是可控的。然而，这种其他条件不变的情况在现实世界中是不真实的。对于像优步这样的公司来说尤其如此，他们为相互依赖的用户提供服务。今天让我们来谈谈其中的一个干扰，以及作为一名受访者，你如何通过分享一些潜在的解决方案来让面试官惊叹。
对于像优步和 Lyft 这样提供双边市场的公司来说，干预将导致通常所说的高估偏差，因为控制组和处理组的成员都在利用资源。例如，如果优步在我们的治疗组中引入了吸引驾驶员的特征，这将意味着我们的对照组中可用的驾驶员更少，并且对治疗效果的最终估计将是不准确的。
这就是实验的设计如此重要的原因！那么我们能做些什么呢？首先，我们可以考虑按位置随机分组，这样我们可以充分隔离治疗组和对照组。通过这样做，当治疗组的机制发生时，我们防止了强加给对照组的外部性。但这里有一个隐藏的权衡:在地理上隔离各组可能会导致我们估计效果的更大标准误差，因为现在每个治疗组和对照组可能有更多我们无法控制的属性。例如，想一想中央商业中心的司机和农村地区的司机。最终，必须做出取舍，作为一名受访者，你会想提到它们。或者，我们可以根据时间随机分组。这克服了我们基于地理随机化的缺点，但只有在治疗效果应该持续很短时间的情况下才有效。相反，如果治疗效果意在捕捉类似于同行转诊方案的效果，那么时间随机化可能不是最理想的。
还有哪些因素会威胁到你的有效性？有很多，所以你面临的挑战是在面试中快速思考，尽可能给出更多可能的答案。更多可能的干扰，请查看下面的文章。
最终，A/B 测试的答案可以而且应该有很大的不同，这取决于谁在提问以及问题是关于什么的。在我看来，最重要的是永远要在语境中回答！任何人都可以背诵一个关于假设检验和 A/B 检验步骤的记忆答案，但真正优秀的候选人是知道如何以及何时应用正确技术的人，是能够根据被检验的假设快速适应并思考不同方法的利弊的人。
最初发表于【https://www.stratascratch.com】。
对抗健忘症:循环神经网络的简史和介绍
只有回顾过去，才能理解生活。必须向前看。
——本杰明·巴顿奇事
这是我关于深度学习和强化学习系列的第二篇文章(第一篇关于卷积神经网络)。
在日常生活中有许多顺序建模问题:机器翻译、语音识别、文本分类、DNA 测序分析等。这些问题大多属于监督学习。模型的输入或输出是大小可变的序列。正常的神经网络难以处理不同大小的输入和输出。
在下面的章节中，我将解释为什么递归神经网络或 RNN 适用于序列建模问题。然后，我将谈论具有代表性的架构香草 RNN、长短期记忆(LSTM) ，以及已经在机器翻译和许多其他用例中得到著名应用的编解码器。最后，我将用 Pytorch 中的一个简单实现来演示 LSTM。
1 为什么选择 RNN
1.1 历史
RNN 的概念是在 1986 年提出的。著名的 LSTM 建筑发明于 1997 年。RNN 知名建筑的数量比 CNN 少得多。俗话说“ 一张图片胜过千言万语 ”暗示着，图像有更多的信息和回旋的空间，所以 RNN 的进化史并不丰富多彩也就不足为奇了。我试图将历史分为三个阶段，分别是香草 RNN 的过载单存储器、LSTM 的多门存储器和 RNN 的注意编码器-解码器架构。
当我带你走过的时候，你会意识到 RNN 进化的主题是与健忘症作斗争。换句话说，每一代 RNN 人都试图尽可能多地记住过去的重要信息，以便更准确地预测未来。
RNN 的演变
1.2 为什么 RNN 致力于可变输入/输出
图片来源:安德烈·卡帕西
普通的神经网络很难处理不同大小的输入和输出。以下是他们无法处理的一些用例。请注意， Many 对于模型的每个输入或输出并不是一个固定的数字。
- 一对多:图像字幕，文字生成
- 多对一:情感分析，文本分类
- 多对多:机器翻译，语音识别
RNN 能够通过一个递归处理单元(单层或多层单元)来处理这些用例，其中隐藏状态源自过去。
该架构的递归性质既是一件好事也是一件坏事。好处是它可以处理不同大小的输入/输出。但这是有代价的，除了回忆过去的困难之外，还有消失/爆炸渐变的问题。任何有一些编程经验的人都会生动地回忆起递归程序是多么容易得到堆栈溢出或内存不足异常。
RNNs
2.1 香草 RNN
基本的 RNN 建筑。来自维基百科
上面是基本的 RNN 体系结构，带有自循环或指向自身的递归指针。 x、o 和 h 为输入、输出和隐藏状态，其中 U、W 和 V 分别为作用于它们的参数。在绿色 RNN 细胞内，可能有一层或多层正常神经元或其他类型的 RNN 细胞。
递归指向结构是 RNN 的中心概念。这意味着几件事:
- 输入和输出的大小是不同的
- 有一个隐藏状态来表示过去的知识，它也被用作下一步的输入。来自先前步骤的隐藏状态，连同当前步骤的输入，用于导出当前隐藏状态。然后用它来导出当前步骤的输出。
- RNN 的每一步共享相同的激活函数和相同的参数集。在上面的例子中，U 、V 和 W 在所有的 RNN 单元之间共享，不管 RNN 网络增长到多大。
- 隐藏状态成为 RNN 的关键组成部分，因为它不仅是输入和输出的桥梁，更重要的是过去和现在。
现在你应该已经注意到 RNN 的瓶颈是所有 RNN 单元之间的共享参数，特别是当网络变得太大时隐藏状态参数 V。一个只有单一记忆的大脑是很容易超载，并且不能记住一段距离以外的过去。
具有多层的普通 RNN 单元可以在一定程度上提高性能，但是逻辑上没有太大的区别，因为它仍然被认为是一维数据的一个处理单元。但是有许多方面的信息需要处理。
2.2 RNN 工作方式的简单例子
我用一个简化的字符级语言模型预测单词“hello”的下一个字符的例子来说明。
简化字符级语言模型。图片来源:安德烈·卡帕西
- 第一步:字符嵌入。字典是[h，e，l，o]。“h”变成[1，0，0，0]，“e”变成[0，1，0，0]，“l”变成[0，0，1，0]，“o”变成[0，0，0，1]
- 第二步:计算误差。随机实例化网络，依次向网络输入字符“h”、“e”、“l”、“l”、“o”。在输入“h”的第一时间步，我们得到输出“o”(因为 4.1 是最大的置信度得分，并且在第四个位置)，而不是预期的“e”(绿色)。对于其他时间步长，反之亦然。我们希望增加绿色位置的置信度得分，并减少其他值。
- 第三步:反向传播。汇总误差，进行反向传播，分别更新 W(hh)、W(xh) 和 W(hy) 的参数。
- 第 4 步:重复第 2 步和第 3 步，直到网络以高置信度预测出正确的字符序列。
2.3 LSTM
LSTM 是最受欢迎的 RNN 建筑，即使它已经诞生了 20 多年。但是为什么是 LSTM 呢？最大的原因是香草 RNN 不能很好地记住过去。香草 RNN 中仅有的几组参数需要处理和记忆太多的信息，很容易超载。
对于像对话和文本这样的连续信息，有几个维度需要处理，比如强调什么，输出什么，忘记什么。LSTM 介绍了三种选择存储器(门)，分别是输入、输出、遗忘门，以及 Sigmoid 函数来表示要处理的信息的百分比。
LSTM 概述。图片来源: ResearchGate
- 输入门:记什么。即。像“a”、“the”这样没有用的词不会出现在输入中。
- 输出门:输出什么。即。一些信息将存储在隐藏状态中，但不会存储在输出中。
- 忘门:忘什么。即。背景变了。以前的一些信息会被遗忘
- 乙状结肠函数:信息百分比。sigmoid 函数值在 0 到 1 之间，非常适合用来表示信息输入、输出和遗忘的百分比。
拥有三个逻辑记忆单元来处理不同的维度极大地提高了 LSTM 记忆长期和短期信息的能力。在后一节中，我将通过一个具体的编码示例更详细地说明 LSTM。
2.4 注意编码器和解码器
2.4.1 编码器-解码器
严格来说，编码器-解码器是一个不属于 RNN 的通用架构。在序列中广泛应用于对深度学习用例进行排序。变换器是另一种不基于 RNN 的编码器-解码器架构。OpenAI 最先进的预训练 NLP 模型 GPT-2 和 GPT-3 基于变压器架构。
编码器-解码器架构。图片来源: Quora
编码器-解码器试图模仿人脑的认知过程。例如，当我们看到一些东西，我们将它作为某种格式(编码向量)编码到我们的“神经网络”(大脑)中。当我们想要描述我们所看到的东西时，我们从大脑中取出编码向量，并通过我们的嘴将其“解码”成我们自己的语言。
编码器末端出来的向量还有一个名字叫做潜在空间。潜在空间是机器学习中一个非常重要和有用的概念。这意味着对于任何类型的信息(即语音、文本、图像或视频)，只要它们可以在相同的潜在空间中被表示，它们就可以相互交流和理解，例如图像到文本(图像字幕)和语音到文本(语音识别)。
2.4.2 注意事项
香草编码器解码器有什么问题？来自编码器端的定长向量是编码器和解码器之间唯一的交换媒介。解码器仅在编码器的最后一步之后才暴露给编码器结果。编码器矢量已成为信息瓶颈。距离越远，信息就越难以保存在编码器矢量中。
香草 RNN 的问题听起来熟悉吗？是的。具有更多存储器的相同解决方案也适用。不是一个固定长度的编码向量，我们为每个目标词准备了一个向量，叫做注意力向量。注意力向量与隐藏状态和输入一起被用于预测输出。
注意编码器-解码器。图片来源: ResearchGate
直观上，每个注意力向量允许每个目标单词只关注输入中的几个单词。下面是一个机器翻译例子的注意力矩阵热图。您可以看到，每个目标单词将更多的注意力集中在几个输入单词上。
来自 Google Tensorflow 机器翻译示例的注意力热图
2.5 RNN 调谐技术
大部分神经网络整定技术也可以用来提高 RNN 性能，如脱落、批量归一化、残差学习、激活函数、等。您必须根据您的用例尝试各种技术来获得最佳性能。神经网络调谐在很多时候是一门艺术而不是科学。
3 示例:Pytorch 中 LSTM 的实现
3.1 使用案例
我使用了 torchtext 的 AG 新闻数据集进行文本分类。输入是新闻文本，分为 10 个类别的标签。
Pytorch 的嵌入用于编码输入。为了实现高效的批处理，每个输入的长度限制为 50。超出的单词将被截断，而短缺的单词将被“DUMMY”填充。请参照本笔记本。
3.2《LSTM 执行计划》
以上 LSTM 部分的建筑形象也请参照执行。
3.2.1 遗忘门
*# Forget Gate Calculation*
forget_gate = torch.sigmoid(torch.matmul(embedded_input, self.f_x) + torch.matmul(h, self.f_h) + self.f_b)
3.2.2 输出门
# Output Gate Calculation
output_gate = torch.sigmoid(torch.matmul(embedded_input, self.o_x) + torch.matmul(h, self.o_h) + self.o_b)
3.2.3 输入门
# Input Gate Calculation
input_gate = torch.sigmoid(torch.matmul(embedded_input, self.i_x) + torch.matmul(h, self.i_h) + self.i_b)
3.2.4 新状态&输出
# mid state for new state calculation
input2_state = torch.tanh(torch.matmul(embedded_input, self.i2_x) + torch.matmul(h, self.i2_h) + self.i2_b)# New State after the LSTM Cell
state = input2_state * input_gate + state * forget_gate# New Output from the LSTM Cell
h = output_gate * torch.tanh(state)
3.2.5 检测结果
我只对这个模型进行了 10 个时期的训练和测试。准确率从 0.29 提高到 0.78。
Done Training with Epoch 9 - Loss: 0.30023258924484253\. Test Accuracy: 0.7806578947368421
4 .结论
在本文中，我简要地谈到了一些 RNN 建筑，我还用 Pytorch 中的一个简单实现来说明 LSTM。RNN 有独特的能力来处理顺序建模问题，RNN 的演变完全是为了从过去中记住尽可能多的重要信息，以便更准确地预测未来。
人在同一条河里走两次 。许多现实生活中的用例是顺序依赖的。我很有信心，除了 LSTM，更新更好的 RNN 将会出现，RNN 将继续在人工智能行业扮演重要角色。
Rasch 模型的贝叶斯方法(项目反应理论)
使用 Rasch 模型和 PYMC3 客观地衡量人的表现
客观测量的挑战
客观地衡量个人在评估或测试中的表现，提出了独特的挑战。以一个有 20 个问题的测试为例，其中前 15 个很容易，后 5 个比较难。
测试分数示例
我们在上面看到，人 A 比人 B 多答对了 4 道题，B 比人 C 多答对了 4 道题。基于此，我们可以断言人 A 和人 B 的知识差异与人 B 和人 C 的知识差异相同。然而，这忽略了测试的一个关键组成部分，即每个问题之间的难度差异。如果人 A 答对了 5 道难题中的 3 道，但人 B 和人 C 都没有答对任何一道难题，该怎么办？凭直觉，我们会得出这样的结论:A人和 B 人的知识差异大于 B 人和 c人人的知识差异
拉希模型
以乔治·拉希命名的拉希模型旨在通过分析作为两者函数的测试结果来解决上述挑战，即人 能力 和问题 难度 。因此，个人 i 答对问题 q 的概率是个人潜在能力和问题固有难度的函数。
具体而言，Rasch 表明:
其中 ⍺ =个人潜在能力 𝝳 =潜在困难的问题
这简单来说就是能力和难度之差的逻辑回归，潜在能力在潜在难度之上越高，个人答对问题的概率就越高。
目标是根据我们观察到的反馈来评估能力和困难。对于 NxM 矩阵(N =回答者数量，M =问题数量)，我们需要估计 N 个潜在的能力和 M 个潜在的困难。
最大概似法
假设 i.i.d .数据使用上述模型的可能性为:
其中𝝈(⍺-𝝳) = (⍺-𝝳) / (1 + e^((⍺-𝝳))
对数似然
对数可能性是:
其中𝝈(⍺-𝝳)=(⍺-𝝳)/(1+e^((⍺-𝝳))
目标是找出能够最好地解释我们使用上面的对数似然方程观察到的数据的 ⍺ 和𝝳。
贝叶斯方法— PYMC3
Rasch 模型有可能过度拟合，尤其是在小数据的情况下。如下所示，对潜在变量 ⍺ 和𝝳设置独立的先验有助于防止过度拟合，并解决参数的不确定性。
数据
假设我们进行了一次由 16 名学生和 5 个问题组成的大学考试。我们的数据是一个 16x5 的二分矩阵，如下所示。
探测
像许多考试分布一样，我们的结果显示了一个钟形曲线(左图)，其中大多数学生得到了 40%(只有 2 个问题正确)。请注意，1 名学生答对了所有 5 道题，1 名学生答错了所有题。第二，问题的难度似乎在增加；13/16 的学生答对了问题 A，但只有 3/16 的学生答对了最后一个问题(问题 E)。
分数分布(左)和问题难度百分比(右)
模型拟合
下面是 pymc3 的实现，使用先验的正态分布来估计能力和难度参数。
结果
参数不确定性
在 logit 中测量能力和难度变量，以便在线性标度(-∞到∞)上表达测量结果。因为我们的贝叶斯方法，我们可以解释“真实”参数的不确定性。每个人会有一个能力的分配，每个问题会有一个难度的分配，如下所示:
Logit 中的能力和难度度量
查看能力图表，看起来人 0 具有最高的能力(即，对于该测试最聪明)，而人 12 具有最低的能力；尽管每个人都有相当多的不确定性。同样的故事对于潜在的困难；很多不确定性，但很明显，除了问题 B 和问题 c 之外，每个问题的难度都在增加。它们在难度上似乎有相当大的重叠。
模型预测
有了我们现在估计的潜在参数，我们可以预测一个特定的人答对一个特定问题的概率。因为我们的贝叶斯方法，他们的概率是不确定的。
下图显示了两个不同的人(第 5 个人和第 1 个人)答对同一个问题(问题 D)的概率。尽管两者都有很大的不确定性，但看起来人 1 更有可能以 60%的平均概率答对，而人 5 的平均概率为 37%(如三角形所示)。事实上，因为我们有模拟的概率，我们可以断言有 20%的机会第 5 个人比第 1 个人更有可能答对问题 D。
在右图中，我们可以看到与被采样的人-问题对的能力和难度相关联的联合密度。随着你向图的右下方移动，你的能力和问题难度之间的差异增加，这反过来增加了你回答正确的概率。相反，当你向左上方移动时，问题变得越来越难，你的能力在下降(当然是独立的)，这反过来会降低你正确回答问题的概率。
诊断学
在这一部分，我们将讨论如何深入研究我们的结果，以提出更有意义的问题:
- 范围 预测概率在人-问题对之间如何变化？
- 我们对哪些人的真实能力最没有信心？(也就是说，考试不能区别他们的能力？)
- 有没有人的 结果异常 ？
人-问题对概率分布
每个问题对的排序 HPD 和期望概率
上图是总结预测和每个人在特定问题上的相关不确定性的简洁方式。对于每个问题，预测按预期概率排序(例如，人 0 具有答对 5 个问题中任何一个的最高预期概率。
个别检查
我们对哪些人的真实能力最没有信心？
左边的图像显示了所有 16 个人潜在能力的标准偏差，从最高到最低排序。
请注意，我们对 0 岁和 12 岁的人的真实能力最没有信心。如果我们检查他们的具体测试结果，我们会看到人员 0 答对了所有 5 个问题，而人员 12 答对了所有 5 个问题。这很直观，因为测试不能有效地衡量他们的能力。如果一个人所有的问题都答对了，我们是否认为他是无限聪明的(即有∞能力)？不太可能，他们的能力是有限的，但我们不确定在给定的具体测试其测量。
不寻常的嫌疑人
是否有任何个人的结果可能有问题(例如作弊？幸运的猜测？).使用 Rasch 模型，我们可以计算装备，这只是每个人在所有问题上的 MSE:
每个人的装备得分
我们立即注意到，11 号人物的着装得分明显高于其他所有人。当我们检查他们的测试结果时，我们观察到:
学生 11 的测试结果
第 11 个人对第一个问题回答错误，但对最后两个问题回答正确。这是一个常见的(也是不适合的)问题，因为前三个问题比最后两个简单。这个人最近两次运气好吗？为什么他们在较简单的问题上做了 0/3，而在较难的问题上做了 2/2？有作弊吗？这套装备对这些异常值很敏感，可以用来揭示这种不寻常的结果。
结论
Rasch 模型提供了一个框架，用于:
- 设计和分析社会测试和调查(例如，评估员工评论)，更重要的是，
- 使我们能够将本质上可能是非线性的原始测试/调查结果转换为线性标度，以便于比较
- 确定具有相似难度的问题，以便排除问题
- 确定问题难度的差距
使用贝叶斯方法对 Rasch 模型至关重要，尤其是在数据有限且不确定性高的情况下。
模型正则化的贝叶斯方法
入门
在这篇文章中，我们探索了我们如何通过贝叶斯先验信念来正则化和控制模型的复杂性。
我目前正在读斯塔尼斯拉斯·德阿纳的《我们是如何学习的》。首先，我不能向任何对学习、教学或人工智能感兴趣的人推荐这本书。
这本书的一个主题是解释为什么人类如此擅长快速学习事物和高效学习的神经学和心理学基础，即只给予有限的经验。Dehaene 关于为什么人类能够如此有效地学习的主要论点之一是因为我们能够降低我们对世界的模型的复杂性。根据奥卡姆剃刀的原理，我们找到最简单的可能模型，即解释我们经历的数据，而不是选择更复杂的模型。但是为什么我们要这样做，即使是从出生开始？一个论点是，与儿童心理学中的频繁主义观点(相信婴儿完全通过他们的经验学习)相反，我们在出生时就已经被赋予了关于世界的先前的信念。**
甚至在我们开始体验这个世界之前，我们的大脑就已经有了固有的知识和惊人的学习能力。娜塔莎·康奈尔在 Unsplash 上的照片
这种简化模型选择的概念在机器学习领域有一个共同的名字:模型正则化。在这篇文章中，我们将从贝叶斯的角度来谈论正则化。****
我们有什么方法可以控制从观察中学习的模型的复杂性？我们可以通过在我们的模型分布上放置一个前来做到这一点。在我们展示这一点之前，让我们简要回顾一下正则化，在这种情况下，分析正则化用于监督学习。
正规化的背景
在机器学习中，正则化或模型复杂性控制是一种基本和常见的做法，以确保模型获得高样本外性能，即使样本外数据(测试/验证数据)的分布与样本内数据(训练数据)的分布明显不同。本质上，模型必须平衡具有小的经验损失(它在给出的数据上有多“错误】)和小的正则化损失(模型有多复杂)。
在正则化中，模型学习在经验损失(其预测有多不正确)和正则化损失(模型有多复杂)之间进行平衡。照片由古斯塔沃·托雷斯在 Unsplash 上拍摄
在监督学习中，正则化通常通过 L2 (Ridge)⁸，L1 (Lasso)⁷，或 L2/L1(elasticnet)⁹)正则化来完成。对于神经网络，也有辍学或早期 Stopping⁴** 等技术。现在，我们将集中于分析正则化技术，因为它们的贝叶斯解释更加明确。这些技术总结如下。**
让我们首先定义我们的数据集和参数:
****
接下来，对于给定的监督学习问题，其中我们希望最小化损失函数(例如，均方误差):
然后，对于每种类型的分析监督正则化技术，我们有以下目标:
- L2(山脊):参数的平方值的处罚(L2 常模)。直观上，这限制了模型参数的大小，同时最小化了模型预测的“错误”程度。
- L1(拉索):参数的绝对值(L1 定额)。直观上，这将一些系数约束为零。你可能注意到下面的正则项是不可微的；这种不可微性导致系数取 0 或非 0 value⁵.****
- L2/L1 (ElasticNet): 这种正则化技术惩罚了参数向量的 L1 和 L2 范数，导致来自 L1 和 L2 回归的正则化结果的组合。
下面是一个对比图，显示了套索、弹性网和脊规则化的标准图，每个都绘制在一个单位球体上。生成该图的代码可以在附录中找到。
说明规则化不同效果的图。左:套索，中:弹力网，右:脊。
总之，这些正则化技术实现了控制模型复杂性的不同目标。在下一部分中，我们将通过将先验信念(以概率分布的形式)强加到我们的模型参数上来导出这些正则化目标，从而直接在先验信念和模型正则化之间建立联系。
作为模型先验信念的模型正则化
让我们通过对模型参数的先验信念，更深入地探究实现正则化背后的概率和优化理论。具体来说，我们将证明:
- L2 正则化(吉洪诺夫 Regularization⁶的特例)通过多元高斯先验实现****
- L1 正则化(LASSO) 是通过多元拉普拉斯先验实现的****
我们将分析回归问题的这些主张，但它们也扩展到其他监督学习任务，如分类。我们将专注于严格地呈现这些主张背后的数学原理(你也可以在本文这里找到这些推导)。让我们开始吧！
作为多元高斯先验的 L2(岭)正则化
直观地说，当使用脊正则化时，我们在模型学习的曲面/超曲面中创建一个脊。杰里米·毕晓普在 Unsplash 上的照片
假设我们再次具有相同的一组观察值 D 和一个参数向量 w ，我们想要优化该参数向量以便对来自 D:
********
使用最大后验概率(MAP)规则，我们可以表明，当我们在 w 上调用高斯先验分布时， w 的后验分布的均值和众数就是岭回归的解。我们首先调用贝叶斯规则:
我们现在定义先验和观测模型分布，假设如下:
a .先验模型(参数 w 上的分布):
b .观察模型(观察值的条件分布 D 以参数为条件):
现在，让我们把这些表达式代入贝叶斯法则:
为了导出我们的 L2 正则化的估计量，我们现在使用映射规则和负对数似然函数将乘积上的表达式转换成和上的表达式。
该操作是允许的，因为:
(I)目标的对数是似然函数的严格单调变换，因此取对数似然函数的最大自变量将保持似然目标的基数并产生相同的最大化自变量。**
(二)任一目标 J( θ )的最大化自变量与负目标 J( θ )的最小化自变量相同。****
因此，论点 w 即最大化对数似然将最小化负对数似然:***
将我们的后验分布代入负对数似然的表达式:
由于对数将乘积转换成和，我们可以将乘积的对数分解成依赖于我们的参数 w 的求和项的和，以及不依赖于 w 的常数。然后，我们可以使用对数规则来简化这个表达式。
(请注意，在第一行中，我们省略了常数，以便将该方程放在一行中。)
********
移除不依赖于我们的参数 w 的项，将表达式乘以常数σ，我们得到:
λ = σ / τ 的设置使得我们的 MAP 估计量也是通过岭回归得到的估计量(当我们的数据以 0 为中心时)😗***
这与我们上面的山脊目标(用于回归)完全一致！在封闭形式中，这产生了正规方程:
其中λI 项用于确保待求逆的矩阵(X^T X)是半正定的，因此是可逆的。
因此，在我们的参数上放置一个多元高斯先验相当于用一个 L2 范数惩罚来正则化我们的参数。
作为多元拉普拉斯先验的 L1(拉索)正则化
利用套索正则化，我们鼓励稀疏性，即把对减少经验损失没有多大贡献的模型系数设置为零。马库斯·斯皮斯克在 Unsplash 上拍摄的照片
我们现在将检查一个具有拉普拉斯先验的类似情况。再次假设我们有一个观察值 D 的数据集和一个参数向量 w ，我们希望对其进行优化，以便对来自 D:
********
再次使用映射规则，当我们在 w 上调用高斯先验分布时，我们可以表明 w 的后验分布的均值和众数是套索回归的解。我们首先调用贝叶斯规则:
我们现在定义先验和观测模型分布，假设如下:
a .先验模型(参数 w 上的分布):
b .观察模型(分布同上):
重复上述步骤(参考下文):
- 使用映射规则写出参数的后验分布和最优参数 w 。*
- 从地图目标中导出负对数似然函数。
- 从负对数似然中移除不依赖于 w 的项
- 适当设置超参数 p、q、α1、和 α2。
下面是套索的相应推导:
(注意上一步我们设置 p = 1，q = 1，和 λ = α_1 / α_2 。)
如前所述，我们已经得到了我们的套索目标(用于回归)，如上一节所述！
为什么这很重要？
照片由 Unsplash 上的 Dmitry Ratushny 拍摄
虽然看起来我们所做的只是调用一些优化、对数和概率分布的技巧，但上述推导的意义可能在前面提到的小说“我们如何学习”的上下文中得到最好的理解。**
如果我，一个人类，正在学习一个世界的模型，为什么我倾向于最简单的模型来解释我的观察？其中一个原因是，我们的大脑甚至在学习之前就对我们学习的模型建立了“先验信念”，这是我们从经验中学习时考虑的因素。然而，我们不是仅仅从经验中学习这些模型，而是用经验来更新我们以前对这些模型的信念。
通过预先相信我们学习的模型必须尽可能简单，我们能够控制我们学习的模型的复杂性，甚至在我们学习它们之前！这正是我们在上面的分析推导中所做的:通过对模型参数分布的先验信念(即“模型参数 w 是正态分布”)，我们能够直接确定这些模型有多复杂。
摘要
在本文中，我们介绍了模型复杂性和正则化 、 的概念，以及这些概念如何与先验信念的概念相关联。我们声称，我们可以控制模型的复杂性，即正则化它，通过对我们的参数分布设置先验信念。然后，我们简要介绍了一些常见的分析，监督正则化技术(岭，套索，和弹性网回归)。然后，我们展示了如何分别使用多元高斯和拉普拉斯先验分布来推导脊正则化和套索正则化的目标函数。最后，我们讨论了为什么这些结果不仅对机器学习，而且对心理学都很重要。****
感谢阅读:)更多强化学习、计算机视觉、编程、优化方面的文章请关注我！
另外，非常感谢 CODECOGS 的在线方程式渲染工具！如果你想在你的中等文章中渲染数学，这是非常有用和容易使用的。
参考
[1]德阿纳，斯塔尼斯拉斯。我们如何学习:为什么大脑比任何机器都学得好……目前来说。企鹅，2020。
[2]拉斯姆森，卡尔爱德华，和邹斌 Ghahramani。“奥卡姆剃刀”神经信息处理系统的进展(2001):294–300。**
[3] Srivastava，Nitish 等人，“辍学:防止神经网络过度拟合的简单方法。”机器学习研究杂志15.1(2014):1929–1958。**
[4]卡鲁阿纳、里奇、斯蒂夫·劳伦斯和李·贾尔斯"神经网络中的过度拟合:反向传播、共轭梯度和早期停止."神经信息处理系统的进展(2001):402–408。**
[5]罗伯特·蒂布拉尼。"通过套索的回归收缩和选择."皇家统计学会杂志:B 辑(方法学)58.1(1996):267–288。
[6]卡尔维蒂、丹妮拉和洛萨·赖歇尔。"大型线性问题的吉洪诺夫正则化."位数值数学 43.2(2003):263–283。
[7]罗伯特·蒂布拉尼。"通过套索的回归收缩和选择."《皇家统计学会杂志:B 辑(方法论)》58.1(1996):267–288。
[8]霍尔、阿瑟·e 和罗伯特·w·肯纳德。"岭回归:非正交问题的有偏估计."技术计量学12.1(1970):55–67。**
[9]邹、惠和特雷弗·哈斯蒂。"通过弹性网的正则化和变量选择."皇家统计学会杂志:B 辑(统计方法学)67.2(2005):301–320。
附录
生成图的代码(改编自这个堆栈溢出帖子)。
一种看待线性回归的美丽方式
一旦你看到它，你以前的想法将只是投影
汤姆·巴瑞特在 Unsplash 上的照片
你知道线性回归是正交投影吗？这对数学家来说是显而易见的，但像你我这样头脑简单的人可能从未想过这个问题。尽管如此，我们仍然可以欣赏它的美丽。知道每一个线性回归都可以被视为一个空间问题是一个游戏规则的改变者。如果你不知道这些，不要难过。你仍然有机会第一次有一个令人兴奋的经历。
最小二乘法是什么，为什么要关心？
最小二乘法是数据拟合中最常用的方法之一。它允许你获取一堆数据，并得出一个数学表达式来模拟这些数据的行为。如果你认为这与你无关，你可能错了。最小二乘不仅仅是数学家和工程师的专利。最小二乘无处不在，属于每个人。他们沉浸在你的手机偏好、你的网飞账户和你的日常生活中。无论你走到哪里，数据都在被收集和用于构建模型，这些模型代表了数据的行为，并预测下一步应该是什么。即使这些模型比我们在这里要解释的更复杂，最小二乘的基本方面仍然存在。
图一。建模数据和观测数据之间的差异。作者在 desmos 中做的图，之前用的这里用的。
这可能是最小二乘法最简单的解释:我们有一些输入数据 x 负责一些输出数据 y 。我们的目标是找到一个计算 x 的数学表达式，并产生一个尽可能接近 y 的 ŷ 。图 1 显示了一些红色的数据点和一条紫色的曲线。数据点是我们试图匹配的观察数据。紫色曲线是我们用来表示红点行为的数学模型。注意我们如何计算观察值( y )和建模值( ŷ )之间的差异。这些差异用字母 r 表示。再说一次，我们的目标是找到一个 r 尽可能小的模型。然而，我们有一个问题: r 可能是负的，也可能是正的，这取决于我们如何计算它。为了解决这个，我们不打算把 r 算成 y - ŷ 或者 ŷ - y 。我们的计算将是:
等式 1。差异的平方
如果我们计算 y 和 ŷ 之差的平方，结果总是正的。然后，最小二乘法包括寻找模型，其中观察数据和建模数据之间的差的平方尽可能小。
传统的解释
观测数据和建模数据之间的差异通常称为残差，数学上表示为:
等式 2。残差
注意 ŷ 是一个函数 f ，使用系数 a 对每个 xi 进行评估。找到这些系数是我们的主要目标。理想情况下，我们想知道哪些系数使我们达到 S 的最小可能值。
等式 3。残差和
为了找到 S 的最小值，我们可以将梯度设置为零，并找到系数 a 。如果你不清楚如何在梯度等于零时找到最小值，你可以访问这篇文章(特别是“使用导数最小化函数的图解说明”一节)。
在线性回归问题中，最小二乘法的应用总是有唯一的解，而对于非线性回归则不是这样。线性问题的解决方案在下面的等式中给出，其解释可以在多本书和网页中找到。
等式 4。未知系数向量
这里要理解的主要内容是，向量 c 包含对数据建模的线性表达式的系数。这个向量是观察值( B )、输入值()A)以及我们想要用作模型的表达式类型的函数。下图显示了使用相同输入数据但更改了模型或方程类型的四个线性回归示例。 A 的每一列代表方程的一项，每一行代表输入值。请注意 c 将始终是一个只有一列、行数等于我们定义的参数数的矩阵。每个图中包含的方程代表了每个模型数据的最佳数学表示。
图二。使用相同输入数据但改变数学模型的线性回归示例。作者制作的图表。
再看一眼
在上图的所有例子中，我们有一个输入数据变量( x )和一个输出数据变量( y )。然而，我们可以对输入数据使用多个变量。我们可以有这样一个函数:
等式 5。依赖于两个独立变量的模型
在这种情况下，我们可以获得一个曲面，而不是获得一条描述模型和数据之间最佳匹配的直线。如果我们不断向输入数据中添加更多的变量，我们可以找到更多的最佳拟合系数。因此，最小二乘法和线性回归不仅适用于图 2 中的图，您还可以应用这种方法来找到代表多个独立变量的数学模型。
当应用最小二乘法进行线性回归时，我们可以用不同的方式来思考。假设我们有一个矢量，由图 3a 中的蓝线表示。这个向量的位置也标记了一条线在 xy 平面上的位置(蓝色细虚线)。现在让我们说，我们想找到那条线上离平面上另一个点最近的点是什么，在这种情况下， B 。这类似于问 B 到蓝线的最小距离是多少。该最小距离对应于 B 在直线上的正交投影。图 3b 示出了代表该投影的点 X 。如你所见，从 B 到 X 的绿线与蓝线成 90 度，这意味着 X 是 B 在蓝线上的正交投影。
图 3。(a)点 B 在由向量 a 定义的直线上的正交投影，(B)点 B 到其正交投影的距离。作者制作的图表。
现在的问题是:怎样才能找到 X ？图 3b 显示有一个常数 C 与向量 A 相乘，这样 A 的位置就是我们正在寻找的值。所以寻找 X 的问题可以通过确定 a c 乘以将使 B 到蓝线的距离最小来解决。**
首先要做的是找到计算 B 和 A 之间距离 d 的方法。一种方法是使用这些点之间的欧几里德距离。我们可以如下计算该距离:
等式 6。二维空间中两点之间的欧氏距离
注意 Bx 、 Ax 、 By 和 Ay 分别对应 A 和 B 在 x 和 y 轴上的坐标。这是这种距离计算的一个很酷的特性。对于这个例子，我们正在计算平面上两点之间的距离。我们还可以计算空间中两点之间的距离，甚至可以计算 10 维空间中两点之间的距离。等式总是相同的，可以写成如下形式(其中 N 代表维数):
方程式 7。N 维空间中任意多个点之间的欧几里得距离
我们有一种方法来计算 B 和 A 之间的距离。我们现在需要的是找到哪一个 c 会使这个距离最小化。你知道该怎么做，对吧？让我们对方程求关于 c 的微分，并将其设为 0。在此之前，有一点非常重要，那就是计算 eq 的最小值。7 等同于计算以下各项的最小值:
等式 8。每个维度中多个点之间距离的平方和
这是由于平方根函数的单调性。不要被名字吓到。这就意味着，求函数平方根的最小值，实际上就是求函数平方根自变量的最小值。如果有人问你√5 和√6 哪个更小，你可以很快回答 5，因为平方根函数是单调的。
回到我们的讨论，目标是取情商。8 并计算 c 使得 d 最小。如果我们对这个方程求导，我们会得到:
等式 9。对等式 8 求微分并将其设置为零
等式中包含的求和。如果我们用矩阵而不是单个值来工作，9 可以被替代。假设 A 表示所有维度上的 A 的值的数组(在 2D 问题中，这将意味着 Ax 和 Ay ),而 B 表示另一个数组，其值为所有维度上的 B 。那么我们可以将前面的等式表示为:
方程式 10。情商。9 矩阵形式
记住，要乘矩阵，第一个矩阵的列数需要与第二个矩阵的行数相匹配。这就是为什么要将 A 乘以 B 或 A 乘以 A 我们需要计算 A 的转置。
从上式我们可以得到 c ，即:
方程式 11。使点 B 和由矢量 A 定义的直线之间的距离 d 最小的矢量 c
这个值 c 就是我们一直在寻找的，并且是(令人惊讶的可能？)我们之前在等式 4 中使用的。这是什么意思？从投影的角度来看， c 代表点 B 的正交投影在矢量T5a**定义的直线上的位置(图 3)。从线性回归的角度来看， c 代表乘以 A 中每一行的系数，这将引导您找到输入数据的最佳可能表示(图 2)。这可能看起来是两件完全不同的事情，但它们实际上是有联系的。当我们进行线性回归时，我们会找到包含在的每一行中的函数的线性组合。在直线的例子中，中只有一行，所以求这个单一函数的线性组合实际上就是求 B 在直线上的投影。****
是时候举个例子了！假设我们想要计算点 B =(4，2)在由矢量 A =(1，2)定义的直线上的投影，如图 4 所示。对于这种情况，我们可以定义一个矩阵 A 和一个矩阵 B 并用我们在等式上找到的表达式计算 c 。11.
图 4。向量 a 定义的直线上 B 点投影的计算示例。作者制作的图形。
B 在直线上的投影位置为X=A。 c 即(1.6，3.2)。那么，这和线性正方形有什么关系呢？假设我们不是将 A 和 B 读取为两个点，而是将它们读取为一对输入/目标数据。在这种情况下，我们将有两个数据点:(1，4)和(2，2)，我们希望使用线性回归来拟合模型。如图 5 所示，我们找到的线性回归系数也是 1.6。这意味着执行线性回归就像寻找目标向量在子空间上的正交投影，该子空间由我们想要包含在回归中的每个函数构成。在这种情况下，点(4，2)被投影到由向量(1，2)形成的子空间中。这就像图 2 中的示例 2，其中定义线性回归元素的矩阵只有[x1，x2，…xn]的值。**
图 5。(a)点 B 在向量 a 定义的直线上的投影，(B)点(1，4)和(2，2)的线性拟合。作者制作的图表。
是的，线性回归是一个正交投影，一旦你看到它，一切都有意义。我们甚至可以以之前的例子为例，找到另一个具有相同正交投影的点 E ，注意到线性回归系数是相同的(图 6)。在这种情况下，数据点更靠近直线，因此 R 将增加。然而，两种情况下的斜率完全相同。我们可以找到用相同回归系数调整的点的无限组合，因为有无限多个点的正交投影是 X 。你听说过安斯科姆的四重奏吗？现在是看一看它的好时机。
图 6。(a)点 E 在向量 a 定义的直线上的投影，(b)点(1，0.4)和(2，3.8)的线性拟合。作者制作的图表。
向第三维度的飞跃
到目前为止，我们看到的例子只包含 2 个数据点。这是有原因的。拥有 N 个数据点意味着我们想要投影的向量是 N 维的，难以可视化。假设我们有一组 100 个数据点，我们希望调整到以下形式的线性回归:
方程式 12。具有 3 个系数的线性表达式示例
在这种情况下，我们会有一个 100 维的向量，我们想投影到一个 3 维空间。你能想象这个吗？也许太多了。让我们用一个更简单的例子:我们有一个 3 点的数据集，我们想用两个系数的线性回归来调整。这如图 7 所示。
图 7。3 点数据集的 y=a+bx 类型的线性回归。作者制作的图表。
如果我们将线性回归应用到前面的例子中，我们会发现最佳拟合出现在 a=-⅓和 b=3/2 时。我们如何在三维空间中表现它呢？对于这种情况，我们有一个目标向量t=【2，1，5】，我们希望将其投影到由向量=【1，1，1】和B=【1，2，3】形成的曲面上。记住我们要找的表达式有一个系数乘以 x (向量 A )和一个偏差或者系数乘以 1(向量 B )。请看图 8。**
图 8。点 t 在向量 A 和 b 形成的子空间上的投影。作者使用这个 Python 笔记本制作的图形。
点 c 表示目标向量T3t在由定义线性回归的向量形成的表面上的正交投影。 c 为(-0.33，1.5)的原因是，如果我们想象一个由B=(1，1，1)为 y 轴、 A** =(1，2，3)为 x 轴组成的 2D 坐标系， c 在 y 为负， x 为正。如果我们改变想要投影的点的位置，我们将看到它在 2D 子空间上的位置也相应地改变(图 9)。**
图 9。点 t2 在向量 A 和 b 形成的子空间上的投影。作者使用这个 Python 笔记本制作的图形。
类似于我们之前所做的，我们现在可以找到无穷多个点，它们在平面上的投影也是 c 。这意味着这些点将使用相同的线性回归系数进行调整，尽管这些点到模型的距离会发生变化。如果你想玩不同的点和平面，欢迎你使用我上传到 GitHub 的这个 Python 笔记本。我试图尽可能多地解释我在代码的每一部分做了什么。
在前面的例子之后，可能更容易想象这样一种情况:我们想要将属于 100 维空间的一个点投影到由 2 个向量构成的 2 维空间中。很难对这个 100 维空间的样子有一个清晰的描述，但是，如果我们外推我们之前所做的，毫无疑问，我们将在 2D 空间中找到一个点，它代表原始点在 100 维空间中的正交投影。来自匹兹堡大学的约翰·d·诺顿教授的这篇文章包含了一个关于如何在四维空间中可视化事物的很好的解释。我会把 100 维空间里的点的画面留给你去想象！
结论
这篇文章所写的并不新鲜。正如我在引言中所说，如果你是一名数学家，很可能所有这些对你来说都是显而易见的。然而，我决定写这篇文章的原因是，在不同的程序中运行多元线性回归之后，我从未停下来思考我实际上在做什么。当我意识到线性回归实际上是正交投影时，我觉得我终于明白了我多年来一直在做的事情。这帮助我认识到为什么线性回归是有封闭解的问题，以及为什么在某些情况下它们不是一个好主意。无论如何，不管你的数学知识如何，我希望你会觉得这很有趣，就像我几天前翻阅我的旧线性代数书时发现的一样。
参考
- 弗拉基米尔·米库利克(2017)。为什么线性回归是投影。
- 托马斯·s·罗宾逊(2020)。计量经济学的基本定理。第三章。
- 约翰·诺顿(2001 年)。四维空间是什么样的？
- Christopher M. Bishop (2006)模式识别和机器学习。斯普林格。
探索性数据分析的初学者困境
探索性数据分析(EDA)是数据科学项目中的一个重要步骤，在这里您可以对数据有所了解。
对于初学者来说，EDA 可能会带来一些挑战。本文讨论了每个探索性数据分析初学者在某个时间点可能面临的挑战之一。本文假设读者具备 EDA 的基础知识。
Firmbee.com在 Unsplash 上拍照
最近，我在玩一个从 Kaggle 获得的玩具数据集(贷款数据)。我使用这个数据集在 Tableau 中创建了一个仪表板，并将其发布到 Tableau Public(您可以在这里找到已发布的仪表板)。在我的数据科学之旅的早期，我面临着一个两难的选择，即从数据中选择正确的答案。我觉得值得与这一领域的初学者分享。
让我们用一个例子来理解这个困境。在贷款数据集中，假设我们需要找出"哪种类型的贷款(数据集中的“目的”特征)最有可能出现违约？”。我能想到两种方法来寻找答案。
方法 1
在这种方法中，我首先只选择已经违约的借款人(在“未全额支付”功能中为 1)，然后绘制这些违约借款人的贷款类型条形图。那么这个图看起来会像下面这样。
违约者的贷款(图片由作者提供)
上图显示，大多数违约者接受了“债务合并”贷款。因此，我们可以说“债务合并”贷款的违约率最高。
方法 2
在这种方法中，我们将绘制一个堆积条形图，以查看贷款类型的违约比例。
按贷款类型划分的违约比例(图片由作者提供)
上面的情节说的是另外一个故事。在这里，“小企业”贷款的违约率最高。
哪种方法是对的？
方法 2 是回答“哪种类型的贷款最有可能出现违约？”这个问题的正确方法。那么，方法 1 有什么问题呢？
方法 1 回答了“哪种贷款最受违约者欢迎？”。在方法 1 中，我们将“债务合并”贷款放在顶部，因为这是贷方提供的最受欢迎的贷款类型(针对违约者和非违约者)。下面的剧情来看看吧。
贷款频率(图片由作者提供)
正如我们所见,“债务合并”是贷方提供的最受欢迎的贷款。超过 50%的贷款用于债务整合。因为，债务合并贷款提供给许多借款人，违约也更多。这并不意味着采取债务合并贷款的人有相对更多的违约。
如何克服这种困境？
1。正确设计问题
正确地提出问题可以解决你 90%的困境。在上面的例子中，我们想知道“哪种贷款类型最有可能出现违约”，而不是“哪种贷款最受违约者欢迎”。
2。相信比例，而不是绝对数字
让我们用绝对数代替比例来试试方法 2。我们将会看到，我们最终会得到与方法 1 相同的结果。
按贷款类型分类的违约频率(按作者分类的图片)
在上面的图中，我们再次看到债务合并贷款的违约率最高。但是，这是不正确的。由于债务合并贷款是由大量贷款人提供的，违约率也会很高。并不是说债务合并贷款违约率最高。
这就好比说，与印度人相比，美国人更有可能在美国的 X 公司失业。假设 X 雇佣了 100 名美国人和 10 名印度人，X 解雇了 10 名美国人和 5 名印度人。这并不意味着美国人更有可能失业。如果你以绝对数字来看，更多的美国人被解雇，但也要记住，他们构成了雇员的大多数。但是，如果你用百分比来看，只有 10%的美国人被解雇，而 50%的印度人被解雇。因此，绝对数字可能会误导人，所以要相信比例。
电影推荐的协同过滤介绍
推荐系统分步指南
推荐系统备忘单(图片来自作者的网站
随着我们对个性化内容推送需求的增加，推荐系统已经成为一个新兴的话题。我想我们都熟悉 YouTube 上的推荐视频，我们都——不止一次——是深夜网飞狂看的受害者。
推荐系统中有两种流行的方法，基于协作的过滤和基于内容的过滤。基于内容的过滤根据内容属性(如流派、语言、视频长度)预测观众可能喜欢的内容。而协同过滤基于其他相似用户的偏好进行预测。因此，协同过滤方法倾向于基于实例的学习，通常由手头有大量数据的大公司应用。
在本文中，我将关注基于协作的过滤，并简要介绍如何使用属于这一类别的两种算法进行电影推荐， K 最近邻(KNN)和奇异值分解(SVD)。
我使用来自 Kaggle 的电影数据集来预测个人级别的推荐电影。
评级数据集
推荐系统的 EDA
每种机器学习算法都需要不同的方式来探索数据集，以获得有价值的见解。我使用了以下三种技术来研究手头的数据。要查看更全面的 EDA 指南，请查看我的博客。
1.唯一计数和数据形状
首先，概述数据集中包括多少不同的用户和电影。使用df.nunique(axis = 0)很容易做到这一点，然后将其绘制成条形图。
唯一计数代码(图片由作者提供)
2.单变量分析
单变量分析(一次分析一个特征)有助于我们更好地理解三个问题:
- 评论最多的电影有哪些？
- 提供最多评论的用户是谁？
- 收视率的分布情况如何？
# univariate analysis
plt.figure(1, figsize = (16,4))
df['movieId'].value_counts()[:50].plot(kind = 'bar') #take top 50 movies
plt.figure(2, figsize = (16,4))
df['userId'].value_counts()[:50].plot(kind = 'bar') #take top 50 users
plt.figure(3, figsize = (8,4))
df['rating'].plot(kind = 'hist')
单变量分析结果(图片由作者提供)
我们可以从单变量分析中得到一些启示:
1.分级在电影中不是均匀分布的，分级最高的电影是“356 ”,其分级不超过 350；
2.评级在用户中分布不均，用户最多提供 2400 个左右的评级；
3.大多数人可能会给出 4 左右的评级
3.汇总分析
单变量分析给我们更多的是单个电影或用户层面的视图，而聚合分析帮助我们理解元层面的数据。
1。每部电影的收视率分布是怎样的？
ratings_per_user = df.groupby('userId')['movieId'].count() ratings_per_user.hist()
直方图显示，大多数用户(671-80%中的大约 560 人)的评分低于 250。
2。提供评分的用户分布如何？
ratings_per_movie = df.groupby('movieId')['userId'].count() ratings_per_movie.hist()
直方图显示，大多数电影(大约 9，066-90%中的 8，200 部)的评分低于 25 分。
在这个阶段，我们应该对手头的数据有一个相当清晰的了解。
基于协作的过滤算法
我想介绍两种基于协作的过滤算法——K 近邻和奇异值分解。惊奇库允许我们用几行代码实现这两种算法。
from surprise import KNNWithMeans
from surprise import SVD# KNN
similarity = {
"name": "cosine",
"user_based": False, # item-based similarity
}
algo_KNN = KNNWithMeans(sim_options = similarity)# SVD
algo_SVD = SVD()
但是，为了恰当地实现算法，最好对每种算法背后的理论有一个基本的了解。
1.k 最近邻(KNN)
KNN 插图(图片来自作者的网站
选项user_based: False确定该 KNN 使用基于项目的相似性，因此我们基于具有已知评级的类似项目来预测项目 m1 的未知评级。您可以将 k 近邻算法视为在由 n 个用户定义的 n 维空间中表示电影项目。基于余弦相似度计算点之间的距离，余弦相似度由两个向量之间的角度决定(如图中 m1 和 m2 所示)。余弦相似度优于欧几里德距离，因为当数据集维数较高时，它受到的影响较小。
2.矩阵分解—奇异值分解(SVM)
SVD 插图(图片来自作者的网站)
奇异值分解是一种矩阵分解技术，将矩阵分解为低维矩阵的乘积，然后从最高重要性到最低重要性提取潜在特征。这是一个相当长的句子，所以让我把它分解一下…
它不像 KNN 那样遍历单个评级，而是将评级矩阵视为一个整体。因此，与 KNN 相比，它的计算成本更低，但可解释性也更差。
SVD 提取潜在特征(它不是数据集中包含的实际特征，而是算法神奇地发现的有价值的隐藏特征)以形成分解矩阵 U 和 V 转置，并将它们按特征重要性降序排列——就像图中从深蓝色到浅蓝色。然后，它通过采用基于特征重要性的加权方法转置的 U 和 V 的乘积来填充空白评级。这些潜在特征参数通过最小化误差来迭代学习。
说到误差，现在来说说模型评估。
模型评估
协同过滤技术将推荐系统表示为一个回归模型，其输出是一个数字评分值。因此，我们可以将回归评估指标应用到我们的推荐系统中。如果您想深入了解常见的回归评估指标，例如线性回归，您可能会发现“简单实用的线性回归指南”中的模型评估部分很有帮助。
在这个练习中，我用以下两种方法来评估 KNN 和奇异值分解。
1.交互效度分析
惊喜库提供了自动执行交叉验证的cross_validate功能。为了让惊喜库理解数据集，我们需要使用load_from_df将数据集摄取到惊喜阅读器对象中，并将评分范围保持在 0 到 5 之间。
from surprise import Dataset
from surprise import Reader# load df into Surprise Reader object
reader = Reader(rating_scale = (0,5))
rating_df = Dataset.load_from_df(df[['userId','movieId','rating']], reader)
然后将算法 _KNN 和算法 _ 奇异值分解传递给交叉验证函数，进行 5 次交叉验证。
from surprise.model_selection import cross_validatecross_validate_KNN = cross_validate(algo_KNN, rating_df, measures=['RMSE', 'MAE'], cv=5, verbose=True)cross_validate_SVD = cross_validate(algo_SVD, rating_df, measures=['RMSE', 'MAE'], cv=5, verbose=True)
结果显示了 KNN 和奇异值分解的比较。如图所示，奇异值分解具有较小的 RMSE、平均熵值，因此性能优于奇异值分解，并且计算时间也少得多。
交叉验证结果
2.训练测试分割评估
这种方法将数据集分成 80%用于训练，20%用于测试。与交叉验证中迭代模型构建 5 次不同，它将只训练模型一次并测试它一次。我已经定义了函数train_test_algo来打印出 RMSE，平均误差，平均误差并返回测试数据帧。
from surprise.model_selection import train_test_split
from surprise import accuracy# define train test function
def train_test_algo(algo, label):
training_set, testing_set = train_test_split(rating_df, test_size = 0.2)
algo.fit(training_set)
test_output = algo.test(testing_set)
test_df = pd.DataFrame(test_output)
print("RMSE -",label, accuracy.rmse(test_output, verbose = False))
print("MAE -", label, accuracy.mae(test_output, verbose=False))
print("MSE -", label, accuracy.mse(test_output, verbose=False))
return test_df
我们来对比一下模型精度，一窥测试输出。
train_test_KNN = train_test_algo(algo_KNN, "algo_KNN")
print(train_test_KNN.head())train_test_SVD = train_test_algo(algo_SVD, "algo_SVD")
print(train_test_SVD.head())
训练测试分割评估结果
结果与交叉验证非常相似，表明 SVD 误差较小。
提供顶级推荐
仅仅建立模型是不够的。正如您在上面看到的，当前的测试输出只预测随机分配到测试集的用户或电影的评级，我们还希望看到带有电影名称的实际推荐。
首先，让我们加载电影元数据表和链接表，这样我们就可以将 movieId 翻译成电影名称。
movie_df = pd.read_csv("../input/the-movies-dataset/movies_metadata.csv")
links_df = pd.read_csv("../input/the-movies-dataset/links.csv")
movie_df['imdb_id'] = movie_df['imdb_id'].apply(lambda x: str(x)[2:].lstrip("0"))
links_df['imdbId'] = links_df['imdbId'].astype(str)
这是三个数据帧如何链接在一起的示意图。
合并表格(作者图片来自网站
然后我定义了一个prediction(algo, users_K)函数，允许你为你感兴趣的 K 个用户创建一个数据帧，并在调用预测算法的同时遍历数据集中的所有 9067 部电影。
def prediction(algo, users_K):
pred_list = []
for userId in range(1,users_K):
for movieId in range(1,9067):
rating = algo.predict(userId, movieId).est
pred_list.append([userId, movieId, rating])
pred_df = pd.DataFrame(pred_list, columns = ['userId', 'movieId', 'rating'])
return pred_df
最后，top_recommendation(pred_df, top_N)执行以下程序:
1)使用pd_merge()将数据集合并在一起；
2)按用户标识对评分进行分组，并使用sort_values()按评分值降序排序；
3)使用head()获得最高值；
4)返回排序的推荐和最推荐的电影
def top_recommendations(pred_df, top_N):
link_movie = pd.merge(pred_df, links_df, how='inner', left_on='movieId', right_on='movieId')
recommended_movie = pd.merge(link_movie, movie_df, how='left', left_on='imdbId', right_on='imdb_id')[['userId', 'movieId', 'rating', 'movieId','imdb_id','title']]
sorted_df = recommended_movie.groupby(('userId'), as_index = False).apply(lambda x: x.sort_values(['rating'], ascending = False)).reset_index(drop=True)
top_recommended_movies = sorted_df.groupby('userId').head(top_N)
return sorted_df, top_recommended_movies
顺便提一下，当在 dataframe 中应用 merge 时，我们需要更加注意连接在一起的键的数据类型，否则您将意外地得到许多空结果。
最后，比较 KNN 和奇异值分解给出的每个用户的前 3 个预测。
# KNN predictions
pred_KNN = prediction(algo_KNN, 10)
recommended_movies_KNN, top_recommended_movies_KNN = top_recommendations(pred_KNN, 3)## SVD predictions
pred_SVD = prediction(algo_SVD, 10)
recommended_movies_SVD, top_recommended_movies_SVD = top_recommendations(pred_SVD, 3)
KNN vs SVD 推荐(图片来自作者的网站
正如你所看到的，两种算法给出了不同的建议，KNN 在评分方面显得更慷慨。
希望你喜欢这篇文章，并感谢到目前为止！如果您想访问完整的代码，请访问我网站上的代码片段。如果你想阅读我更多关于媒介的文章，我会非常感谢你的支持，注册成为媒介会员。
带回家的信息
本文将带您了解构建推荐系统的过程，并比较 KNN 和奇异值分解提供的推荐。
第一行摘要:
- 推荐系统的 EDA:单变量分析、聚合分析
- 两种协同过滤算法:K 近邻和奇异值分解
- 模型评估:交叉验证与训练测试分割
- 提供顶级建议
更多这样的文章
原载于 2021 年 12 月 6 日【https://www.visual-design.net】。
共线性入门指南:什么是共线性以及它如何影响我们的回归模型
什么是共线性？它如何影响我们的模型？我们该如何处理？
作者在 Canva 上创建的图片
当我们构建回归模型时，我们显然希望对因变量和一个或多个自变量之间的关系进行建模。然而，更多的时候，我们可能会遇到这样的情况，每个自变量的拟合系数“没有意义”，我们无法解释为什么会出现这种情况。如果您遇到这种情况，您的回归模型中可能存在共线性。
什么是共线性？
出现共线性是因为我们用来建立回归模型的独立变量彼此相关。这是有问题的，因为顾名思义，自变量应该是独立的。它不应该和其他自变量有任何相关性。
如果自变量之间存在共线性，就违背了回归分析的关键点。在回归分析中，我们希望隔离每个自变量对因变量的影响。这样，我们可以将每个自变量的拟合系数解释为自变量每变化 1 个单位时因变量的平均变化，同时保持其他自变量不变。
现在如果我们有共线性，上面的关键点就不再成立，就好像我们改变一个自变量的值，相关的其他自变量也会改变。
在这篇文章中，我们将了解为什么共线性会成为我们回归模型的一个问题，我们如何检测它，它如何影响我们的模型，以及我们可以做些什么来消除共线性。
共线性问题
共线性会在几个方面影响我们的模型，它们是:
- 独立变量的系数估计对模型的变化非常敏感，即使是微小的变化。假设我们想要删除或添加一个自变量，那么系数估计值将会大幅波动。这让我们很难理解每个自变量的影响。
- 共线性会增大系数估计的方差和标准误差。这反过来会降低我们模型的可靠性，我们不应该相信我们模型显示的 p 值来判断一个独立变量对我们的模型是否具有统计显著性。
为了更清楚地说明为什么共线性是这样一个问题，让我们看一下下面的用例。
假设我们想预测一辆汽车的价格。为了预测它，我们有独立的变量，如汽车的城市英里数，公路英里数，马力，发动机大小，冲程，宽度，峰值转速和压缩比。接下来，我们建立一个回归模型，下面是我们的模型的统计摘要。
我们的模型实际上做得很好，因为它有 84%的 R。现在问题来了，当我们试图解释这个模型的时候。如果我们看一下系数估计，高速公路 MPG (76.07)和城市 MPG (-211.78)的符号相反。这完全没有意义，因为如果一辆汽车的高速公路 MPG 提高了价格，那么城市 MPG 也应该这样做。但事实并非如此。
此外，模型显示公路 MPG 和城市 MPG 的 p 值不显著(> 0.05)，表明我们可以将它们从回归模型中排除。但它们真的无足轻重吗？如果我们认为模型中可能存在轻微的共线性，我们就不应该马上相信这个 p 值。
检测共线性
有两种简单的方法来检测我们的回归模型中是否存在共线性。
相关矩阵
第一个是通过观察我们自变量的相关矩阵。经验法则是，如果两个独立变量的皮尔逊相关系数大于 0.9，那么我们可以说这两个独立变量彼此高度相关，因此它们是共线的。这是我们用例的关联矩阵。
作者创造的形象
从上面的图像中，我们可以清楚地看到公路 MPG 和城市 MPG 高度相关，因为它们的皮尔逊相关系数为 0.97。由于它们具有正相关性，这意味着如果我们增加高速公路 MPG，城市 MPG 也将增加几乎相同的数量。
方差膨胀因子
方差膨胀因子或 VIF 衡量共线性对系数估计方差的影响。VIF 可以用数学方法描述如下:
从上式我们知道，如果自变量的 Ri 大或者接近 1，那么对应的 VIF 也会大。这意味着自变量可以用其他自变量来解释或者换句话说，*与其他自变量高度相关。因此，系数估计值 βi 的方差也很高。***
下面是我们用例中自变量的 VIF:
在我们决定我们的自变量的共线性是一个值得关注的原因之前，有很多关于什么是 VIF 的合适阈值的讨论，但是大多数研究论文都认为 VIF 高于 10 表明自变量之间存在严重的共线性。
在我们的使用案例中，我们可以看到高速公路 MPG 和城市 MPG 的 VIF 得分远高于 10，表明它们彼此高度相关。从上面的相关矩阵中我们也可以看到这种现象。
查看我们的 综合统计小抄 了解统计和概率的重要术语和方程
消除共线性
既然我们知道独立变量中存在严重的共线性，我们需要找到一种方法来解决这个问题。有两种常见的方法可以消除共线性。
变量选择
这是消除共线性的最直接的解决方案，通常，领域知识对实现最佳解决方案非常有帮助。为了消除共线性，我们可以从回归模型中排除具有高 VIF 值的独立变量。让我们看一下我们的用例示例，为什么领域知识在这种情况下会有帮助:
- 我们知道公路 MPG 和城市 MPG 有很高的 VIF 值。如果我们有领域知识，我们知道没有必要从我们的回归模型中排除这两者。相反，我们只需要选择其中之一。假设我们从模型中排除了公路 MPG。
- 我们还知道马力和发动机尺寸也有相当高的 VIF 值。虽然它们测量的东西不同，但较高的发动机尺寸或发动机排量通常对应于较高的马力。因此，我们从模型中排除了马力。
最后，我们再次建立了我们的回归模型，但这次没有公路 MPG 和马力。
现在独立变量之间不再有严重的共线性。现在我们可以进行回归分析了。
主成分分析
消除共线性的第二种方法是使用主成分分析或 PCA，这是一种常用于降维的方法。这种方法将有利于消除共线性，因为主成分分析将我们的独立变量分解成一定数量的独立因素。
然而，用 PCA 消除共线性有一个很大的缺点。由于我们从主成分分析中得到的独立因素与我们最初的自变量完全不同，我们不再有自变量的同一性。这似乎有点违背直觉，因为我们去除共线性的主要原因是为了让我们更容易理解自变量对因变量的影响。
回归模型中消除共线性的作用
现在我们移除了自变量中的共线性，让我们比较有共线性和没有共线性的回归模型。
左侧是具有共线性的回归模型，右侧是通过变量选择移除共线性后的回归模型。
共线性的问题是，它会夸大系数估计的方差或标准误差。现在，如果我们看一下这两个模型，在没有共线性的回归模型中，系数估计的标准误差比有共线性的模型小得多。最明显的一个是城市 MPG 变量。当存在共线性时，该变量系数估计的标准误差为 169.14，而当消除共线性时为 60.30。
如果我们看一下 p 值，具有共线性的模型得出结论，城市 MPG 变量在统计上不显著，这意味着我们可以从模型中排除该变量以获得更好的性能。但是当我们去除共线性后，这个变量的 p 值是 0.003，实际上是有统计学意义的。共线性会夸大独立变量系数估计的方差，使我们很难相信从模型中得到的 p 值。
此外，在充分选择变量的情况下，无共线性模型的 F-统计量比有共线性模型显著得多，尽管有共线性模型的自变量更多。
我们需要消除共线性吗？
我们应该注意的一件重要事情是，共线性不会影响模型预测或模型的准确性。如果你看看上面有和没有共线性的模型的 R 比较，两者都差不多。事实上，具有共线性的模型通常具有更高的准确性，因为它通常具有更多的独立变量。
共线性仅影响系数估计的方差和 p 值。它影响模型的可解释性，而不是模型的预测能力。
所以，如果你想建立一个回归模型来进行预测，并且不需要了解每个自变量的影响，那么你就不需要去除模型中的共线性。
但是，如果模型解释对您很重要，并且您需要了解每个独立变量对模型预测的影响，那么删除模型中的共线性是必要的。
最初发表于【https://www.stratascratch.com】。**
离散时间马尔可夫链初学者指南
Acme corporation 的收盘价使用 2 态马尔可夫过程模拟(图片由作者提供)
以及如何使用 Python 模拟离散马尔可夫过程的教程
离散时间马尔可夫链可以用来描述系统以一定的概率从一个状态跳到另一个状态的行为，并且这个转移到下一个状态的概率只取决于系统当前处于什么状态，即它不取决于系统在当前状态之前处于哪个状态。
上面的定义很好地总结了离散时间马尔可夫过程或通常所说的马尔可夫链的长短。
但是上面的描述看似简单。正如我们将看到的，即使是最简单的马尔可夫链也能创造出丰富有趣的系统行为模式。
在本文中，我们将互换使用术语马尔可夫过程和马尔可夫链。
一个简单的 2 态马尔可夫链
一个双态马尔可夫过程(图片由作者提供)
上面显示的马尔可夫链有两种状态，或者叫做状态:+1 和-1。这两种状态之间可能有四种状态转换:
- 状态+1 到状态+1:这个转换以概率p11发生
- 状态+1 到状态-1，转移概率p12
- 状态-1 到状态+1，转移概率为 p_21
- 状态 1 到状态 1 的转移概率 p_22
上图被称为马尔可夫过程的状态转移图。
下图显示了表示这个马尔可夫过程的另一种方法。X 轴是时间轴。气泡代表流程在每个时间步可能处于的不同状态。
沿时间轴显示的两状态马尔可夫过程(图片由作者提供)
实际上，在每一个时间步，过程将处于许多可能状态中的一个。在下图中，黑色气泡描绘了一个跨越 4 个连续时间步长的马尔可夫过程的实现:
跨越 4 个连续时间步的 2 状态马尔可夫链的实现(图片由作者提供)
有许多这样的实现是可能的。在一个 2 态马尔可夫过程中，在 N 个时间步上有个 2^N 个可能的马尔可夫链实现。
通过说明马尔可夫过程沿时间轴的行进，我们收集了马尔可夫过程的以下重要性质:
沿着时间维度的马尔可夫链的实现是时间序列。
状态转移矩阵
在 2 状态马尔可夫链中，有四种可能的状态转移和相应的转移概率。我们可以用一个状态转移矩阵 P 来表示它们如下:
一个 2 态马尔可夫过程的状态转移矩阵 P (图片作者提供)
对于 n 个状态的马尔可夫链 (1，2，3，…，n) ，转移矩阵看起来像这样:
一个 n 态马尔可夫过程的状态转移矩阵 P (图片由作者提供)
状态转移矩阵有以下两个重要属性:
- 由于每个元素 p_ij 是一个概率， 0 ≤ p_ij ≤ 1
- 每一行的 P 的总和为 1.0，即
标记过程的转移矩阵的每一行总计为 1.0(图片由作者提供)
这是因为行索引表示在时间 t 的源状态，而列索引表示在时间 (t+1) 的目的状态。如果流程在时间 t 处于源状态 i ，在 (t+1) ，它必须处于一组允许的状态 (1，2，3，…，n) 。
因此，我们可以将 2 状态马尔可夫过程的转移矩阵重新表述如下:
2 态马尔可夫过程的状态转移矩阵 P(图片由作者提供)
介绍马尔可夫分布随机变量
我们现在引入一个随机变量X _ t .**X _ t中的后缀 t 表示时间步长。在每个时间步 t ， X_t 按照某种概率分布从状态空间【1，2，3，…，n】中取一个值。 X_t 可以取的一个可能的值序列是 {X_0=1，X_1=3，X_2=4，X_3=0，…，X_t=k}。
转移概率作为条件概率
在时间 t 处，假定 X_t 在前一时间步 (t-1) 处已经取值 i ，则 X_t 取某个值 j 的概率由以下条件概率给出:
假设马尔可夫链在(t-1)时处于状态 I，那么它在 t 时处于状态 j 的概率(图片由作者提供)
的确，这就是跃迁概率 p_ij 。
马尔可夫性质
马尔可夫属性声明 p_ij 独立于系统在时间 (t-2)，(t-3)，…，0 的状态。马尔可夫属性陈述如下:
马尔可夫属性(图片由作者提供)
n 步转移概率
状态转移矩阵 P 具有这一良好的特性，即如果你将它与自身 k 相乘，那么矩阵 P ^k 包含所有 k 步长的转移的概率，即系统在从状态 i、开始经过 k 个转移后将处于状态 j 的概率
例如，考虑以下两步马尔可夫过程的转移概率矩阵:
双态转移概率矩阵(逐个图像)
两步转移概率计算如下:
2 状态马尔可夫过程的两步转移概率(逐个图像)
在 P 中， p_11=0.625 是从状态 1 开始遍历两个状态后返回状态 1 的概率。
类似地，p_12=0.375 是从状态 1 开始在恰好两个时间步长内到达状态 2 的概率。
这些概率已经考虑了从状态 1 到状态 1(或者从状态 1 到状态 2，等等)的所有可能的方式，这些方式有两步长。
状态概率分布
我们可以继续将 P 永远乘以自身，以观察 n 步概率如何随时间变化。更有趣的是，如果我们能知道在每个时间步 t 上 X_t 的无条件概率分布是什么。
例如，在我们的两步马尔可夫过程示例中，在每个时间步 t ，X_t 可能是+1 或-1 的概率是多少？这些概率构成了所谓的马尔可夫变量 X_t 在时间 t 时的状态概率分布，用π_ t(或δ_ t)表示。 例如，对于由状态+1 和-1 组成的 2 状态马尔可夫过程，状态分布如下:
2 状态马尔可夫过程的状态概率分布(图片由作者提供)
在状态【1，2，3，…，n】上操作的 n 状态马尔可夫过程在时间 t 可能处于这些 n 状态中的任何一个，因此π_ t**是长度为n的向量**
时间 t 时 X_t 的状态概率分布(图片由作者提供)
一般来说， π_t 的每个元素都可以用符号 π _jt 来引用。π_ JT使用两个变量 j 和 t 进行索引，表示进程在时间 t: 处于状态 j 的无条件概率
向量 π 包含马尔可夫过程在时间t处于状态j =【1，2，…n】的无条件概率
由于 π _t 是一个概率分布，其元素总和总是 1.0:
(图片由作者提供)
如何计算 π_t
通常，假设π_ 0的某个值是状态 0 的概率向量。而给定π_ 0，可以看出π_t 可以计算如下:
给定 t=0 时的概率分布和转移矩阵 P (图片由作者提供)，马尔可夫过程在 t 时的状态概率分布公式
计算π*_t 背后的思想是将状态转移矩阵与自身 t 次相乘得到 t 步转移概率，将 t 步转移概率与 t=0 时的无条件概率分布 π _0 相乘。*
请注意上面等式的以下两点:
马尔可夫过程在时间 t 的状态概率分布取决于:
- 初始概率分布π_ 0在时间 t=0，和
- 这取决于时间步长 t。
因此，
马尔可夫分布随机变量的概率分布随时间演化。
马尔可夫过程示例
让我们用一个例子来复习一下到目前为止学过的所有概念。
假设 Acme 公司的股票按照以下规则增加或减少:
- 与前一天的收盘价相比，当天的收盘价或高或低几个百分点。例如，某一天，Acme 的股票收盘价比前一天高 2.3%。在其他日子，它可能会比前一天的收盘价低 0.8%。
- 给定由“前一天”、“昨天”和“今天”表示的任何 3 天序列，如果 Acme 昨天收盘高于前一天，则它今天将以概率 p_11 收盘高于昨天。因此，今天的收盘价有可能比昨天低 (1 — p_11)。
- 我们还假设，如果 Acme 昨天比前天收盘更低，那么它今天再次收盘更低的概率是p22。因此，今天收盘比昨天高的概率是(1-p22)。
您可能已经猜到 Acme 的股票价格可以使用两状态马尔可夫过程来建模。它的状态转换图是这样的:
用于模拟 Acme 股票价格变动的马尔可夫过程的状态转换图(图片由作者提供)
它的转移概率矩阵 P 看起来是这样的:
2 态马尔可夫过程的状态转移矩阵 P(图片由作者提供)
现在让我们确定这些概率的一些样本值。假设 Acme 的价格连续两天上涨的概率是 0.6，价格连续两天下跌的概率是 0.25。因此，
p11 = 0.6和p22 = 0.25
因此，我们有:
p12 = 1—p11 = 0.4，并且，p21 = 1—p22 = 0.75
Acme 股票的状态转移矩阵如下:
Acme 股价运动的状态转移矩阵(图片由作者提供)
Acme 股票的马尔可夫过程模型的状态转移图如下:
Acme 股票运动的马尔可夫过程模型的状态转换图(图片由作者提供)
我们现在要计算下面的无条件概率分布:
2 状态马尔可夫过程的状态概率分布(图片由作者提供)
让我们假设一个初始值为**_ 0 =【0.5，0.5】，即与 IPO 价格相比，它在上市日收盘上涨(+1 状态)或下跌(-1 状态)的概率相等。如果我们重复应用π_t =π_ 0 *****p^t的公式，我们将得到每个时间步 t 的概率分布向量π【t46 _】
下面的 Python 代码计算了π**_t:**
****import** numpy **as** np
**from** matplotlib **import** pyplot **as** plt
***#initialize the transition matrix P*** P=np.**array**([[0.6,0.4],[0.75,0.25]])
***#initialize pi_0*** pi_0=np.**array**([0.5, 0.5])
***#set up the array to accumulate the state probabilities at times t=1 to 10***pi=[]
pi.**append**(pi_0)
P_mul=P.copy()
***#calculate the state probability for each t and store it away* for** i **in range**(10):
P_mul=np.**matmul**(P_mul,P)
pi_t = np.**matmul**(pi_0,P_mul)
pi.**append**(pi_t)
pi = np.**array**(pi)**
上面的代码将所有计算出的 π_ t 向量存储在数组 π中。 让我们分别绘制组件π_ 1t和π_ 2tofπ_t=【π_ 吧**
****#plot pi_1t = P(X_t = +1) versus t**
fig = plt.**figure**()
fig.**suptitle**(**'Probability of closing higher than previous day\'s close'**)
plt.**plot**(**range**(**len**(pi)), pi[:,0])
plt.**show**()**#plot pi_2t = P(X_t = -1) versus t** fig.**suptitle**(**'Probability of closing lower than previous day\'s close'**)
plt.**plot**(**range**(**len**(pi)), pi[:,1])
plt.**show**()**
我们得到以下两个图:
(图片由作者提供)
我们看到，在短短几个时间步骤中，无条件概率向量π_t=【π_ 1t、π_ 2t】稳定到稳态值**
事实上，可以证明，如果具有以下转移矩阵的两状态马尔可夫过程“长时间”运行:
2 态马尔可夫过程的状态转移矩阵 P(图片由作者提供)
然后将状态概率分布π_t定态为以下常数(极限)概率分布，该分布独立于 t 和初始概率分布π_ 0***😗****
2 状态马尔可夫过程的状态概率的极限分布(图片由作者提供)
使用马尔可夫过程模拟 Acme 的股票价格运动
让我们使用时间 t 处的概率分布 π_t 来模拟 Acme Corp .在每个时间步长 t 的股票价格运动。模拟过程如下:
- 假设 Acme 的 IPO 价格为 100 美元。
- 设置初始概率分布:
π_0=[P(X_t = +1)=0.5，P(X_t = -1) = 0.5]。 - 将+1 马尔可夫状态映射到在区间[0.0%，2.0%]内以随机百分比增加 Acme 前一日收盘价的动作。
- 将-1 马尔可夫状态映射为在区间[0.0%，2.0%]内以类似的随机百分比降低 Acme 前一天的收盘价。
- 在每个时间步 t ，计算状态概率分布 π_t=[P(X_t = +1)，p(x _ t =-1)= 0.5】，通过使用公式π_t =π**_ 0 ***
- 在区间【0，1.0】产生一个均匀分布的随机数。如果该数小于或等于 π_1t = P(X_t = +1) ，则从前一时间步开始，以区间【0.0%，2.0%】内的随机百分比增加收盘价，否则以相同的随机百分比减少前一收盘价。根据需要重复此步骤。
这是 Acme 在 365 个交易日内的股价变化图:
Acme corporation 的收盘价使用 2 态马尔可夫过程模拟(图片由作者提供)
下面是生成上述图形的源代码:
*****#Simulate the closing price of a company*** closing_price = 100.0
***#initialize pi_0*** pi_0=np.array([0.5, 0.5])
***#create a random delta in the range [0, 2.0]*** delta = random.random() * 2
***#generate a random number in the range [0.0, 1.0]*** r = random.random()
***#if r <= P(X_t = +1), increase the closing price by delta,
#else decrease the closing price by delta* if** r <= pi_0[0]:
closing_price = closing_price*(100+delta)/100
**else**:
closing_price = math.max(closing_price*(100-delta)/100,1.0)
***#accumulate the new closing price*** closing_prices = [closing_price]
P_mul=P.copy()
T=365
***#now repeat this procedure 365 times* for** i **in** range(T):
***#calculate the i-step transition matrix P^i***P_mul=np.matmul(P_mul,P)
***#multiply it by pi_0 to get the state probability for time i***pi_t = np.matmul(pi_0,P_mul)
***# create a random delta in the range [0, 2.0]***delta = random.random() * 2
***# generate a random number in the range [0.0, 1.0]***r = random.random()
***# if r <= P(X_t = +1), increase the closing price by delta,
# else decrease the closing price by delta*****if** r <= pi_t[0]:
closing_price = math.max(closing_price*(100+delta)/100,1.0)
**else**:
closing_price = closing_price*(100-delta)/100
***# accumulate the new closing price***closing_prices.append(closing_price)
***#plot all the accumulated closing prices*** fig = plt.figure()
fig.suptitle(**'Closing price of Acme corporation simulated using a Markov process'**)
plt.xlabel(**'time t'**)
plt.ylabel(**'Closing price'**)
plt.plot(range(T+1), closing_prices)
plt.show()**
以下是本文中使用的完整源代码:
离散时间马尔可夫过程模拟
引用和版权
形象
本文中的所有图片的版权归 CC-BY-NC-SA 所有，除非图片下方提到了不同的来源和版权。
感谢阅读！如果您喜欢这篇文章，请 关注我 获取关于回归和时间序列分析的提示、操作方法和编程建议。
端到端机器学习初学者指南
实践教程
学习培训、调整、部署和监控模型
Unsplash 上 Modestas Urbonas 的照片
监督机器学习是一种无需显式编程，将一系列输入(X)映射到一些已知输出(y)的技术。训练机器学习模型是指机器学习 X 和 y 之间的映射的过程。一旦训练完毕，该模型可用于在输出未知的情况下对新输入进行预测。
机器学习模型的训练只是端到端机器学习生命周期的一个要素。对于一个真正有用的模型，这个映射需要被存储和部署以供使用。这通常被称为将模型投入生产。此外，一旦模型投入生产，就需要监控模型的预测和整体性能，以确保预测的质量不会随着时间的推移而降低。
为了介绍端到端机器学习工作流中的基本概念，我将使用 python 库 Pycaret 。Pycaret 是一个低代码机器学习库，它通过提供一个高级编程接口，并寻求自动执行机器学习中的一些重复任务，来简化和加速整个机器学习工作流。
该库正在快速发展，最近增加了功能，以涵盖整个端到端的机器学习工作流。从模型开发到部署和监控。在下面的文章中，我将使用这个包来简单介绍端到端的机器学习生命周期。
数据
在本教程中，我将使用 Pycaret 的内置数据集“employee”。这由一组关于未指定公司的雇员的特征和一个表示该雇员是否已经离开公司的目标变量组成。这是机器学习中的一个经典分类任务，目标是训练一个模型来预测员工是否可能离开。
数据可以很容易地通过 Pycaret API 导入。在下面的代码中，我们读入数据，并保留一个验证样本，供以后在工作流中使用。
数据的前几行如下所示:
“雇员”数据集的前几行。图片作者。
预处理
Pycaret 有一组模块，包含一套用于特定机器学习任务的函数。我们使用的数据集包含一个分类问题，所以我们将主要使用分类模块。
第一步是导入设置功能。该功能在执行任何其他步骤之前运行。它初始化 Pycaret 环境，并创建一个转换管道来预处理准备建模的数据。当运行 Pycaret 时，它将推断所有特性和目标列的数据类型。
Pycaret 已经推断出特性和目标变量的数据类型。作者图片
如果我们很高兴这些数据类型是正确的，也很高兴依赖 Pycaret 的默认预处理方法，那么我们可以简单地点击 enter，Pycaret 将为建模准备数据，并打印一份报告，描述已经采取的步骤。
下面是这份 59 行报告的前 15 行。设置函数有大量可选参数，可用于创建自定义预处理。例如，参数categorical_features可用于手动指定数据类型未被正确推断的分类列。可用参数的完整列表可在 这里 找到。
预处理报告的前 15 行。图片作者。
在现实世界的机器学习项目中，我们可能会执行更深入的探索性分析和自定义预处理。然而，出于本教程的目的，我们将继续使用默认的预处理。
基线模型
通常，在机器学习工作流中，明智的做法是在转向更复杂的算法之前，先训练一个简单的模型，以开发性能基线。
在撰写本文时，Pycaret 支持 18 种不同的分类算法。完整名单可以在 这里找到 。对于基线模型，我们将使用逻辑回归，并使用函数create_model进行训练。为了选择算法，我们传递在 文档 中找到的缩写字符串。训练之后，Pycaret 将打印一份报告，详细说明我们模型的性能。
创建模式报告。图片作者。
比较模型
通过建立基线模型，我们已经确定预处理和设置足以建立分类模型。
下一步是比较不同的分类算法，以确定哪种算法最适合我们的数据集和问题。Pycaret 有一个名为compare_models()的函数，它允许我们用一行代码比较所有可用算法的性能。
该函数将尝试所有算法，并输出一个按准确度排序的列表。您可以使用sort参数将指标更改为目标。
比较模型。图片作者。
由此可见，随机森林总体上是最好的模型。我们将在余下的工作流程中使用这个模型。
我们再次运行create_model()，这次选择随机森林算法。
调整模型
当我们运行 create_model 时，它会自动使用默认参数。这些不一定是使用的最佳参数集，因此我们需要调整模型以找到最佳选择。运行tune_model()功能，使用随机网格搜索调整模型的超参数。
默认情况下，该功能将使用预定义的参数网格，但这可以通过将自定义网格传递到custom_grid参数中进行自定义。默认情况下，该功能还会优化准确度分数，但也可以使用optimize参数进行定制。
在下面的代码中，我们使用默认的参数网格来调整模型和优化 MCC 分数。
该函数返回一个包含 k 倍验证分数的表，默认情况下，折叠数为 10。
模型调整。图片作者。
解释结果
Pycaret 有一个内置的图表选择来解释模型的结果，可以使用plot_model()函数访问。
下面我们使用这个函数来检查特性的重要性。
特征重要性。图片作者。
让我们也可视化混淆矩阵。
混乱矩阵。图片作者。
部署模型
Pycaret 具有使用 AWS 将模型部署到云中的附加功能。
要在 AWS 上部署该模型，您必须首先在aws.amazon.com上创建一个帐户。创建后，您需要生成一个访问密钥，以便允许 Pycaret 函数写入您的帐户。为此，请遵循以下步骤。
- 登录您的 AWS 帐户。
- 将鼠标悬停在右上角的用户名上。
- 从出现的列表中选择安全凭据。
4.从这里展开访问密钥部分，并单击“创建新的访问密钥”。
5.在这个阶段，您需要根据提示下载凭证文件。稍后您将需要此文件中包含的凭据。
6.要允许 Pycaret 与您的 AWS 帐户交互，您还需要安装和配置 AWS CLI。为此，首先运行以下命令。
curl "[https://awscli.amazonaws.com/AWSCLIV2.pkg](https://awscli.amazonaws.com/AWSCLIV2.pkg)" -o "AWSCLIV2.pkg"
然后运行以下命令:
sudo installer -pkg ./AWSCLIV2.pkg -target /
现在输入aws --version确认所有东西都已经正确安装。您应该会看到类似这样的内容。
现在安装完毕，我们可以使用您的帐户详细信息配置 AWS CLI 了。为此，运行下面显示的命令。它会要求您输入以下信息。
AWS 访问密钥 ID: 这可以在我们之前下载的凭证文件中找到。
AWS 秘密访问密钥:也可以在凭证文件中找到。
默认区域名称:这可以在 AWS 控制台上找到。
默认输出格式:此处应留空。
接下来，我们创建一个 S3 存储桶来存储部署的模型。从 AWS 控制台选择 S3，然后用您选择的名称创建一个存储桶。
现在我们准备使用 Pycaret 来部署我们选择的模型。
如果模型已经部署，您将看到以下消息。
生成预测
为了使用该模型，我们根据之前保留的验证数据生成预测。
下面显示的代码从 S3 加载模型，并在删除标签的情况下根据验证数据生成预测。
让我们通过运行predictions[:5]来查看前 5 个预测。
前 5 个预测。作者图片
监视
生产机器学习工作流的一个重要方面是跟踪和监控所执行的实验。Pycaret 与管理端到端机器学习生命周期的开源平台 MLflow 集成。
要通过 Pycaret 使用 MLflow，我们需要导入 MLflow(这应该已经与 Pycaret 一起安装了)并设置跟踪 URI。然后，在调用 setup 函数时，我们添加一些额外的参数，如下所示。
现在，如果我们将跟踪 URI 复制到浏览器中，您应该会看到 mlflow UI 和它所跟踪的实验。
mlflow UI。作者图片
我们可以点击查看每个实验的度量、工件和参数。
实验跟踪。作者图片
这是一个简单的教程，学习端到端机器学习项目中涉及的基本步骤。在现实世界中，大多数机器学习问题、数据和部署解决方案需要更复杂的处理。然而，出于本教程的目的，我使用了一个简单的数据集和 python 库来帮助您开始了解端到端机器学习生命周期。
Pycaret 是一个低代码机器学习库的例子。有许多正在开发的工具试图以不同的方式简化机器学习的开发。要了解更多关于这些低工作量机器学习库的信息，请参阅我之前的文章。
有关现实世界中机器学习的更多信息，请参见下面的文章。
感谢阅读！
使用 PyTorch 几何图形的神经网络初学者指南—第 1 部分
PyTorch 几何入门
不知何故，你偶然发现了图形神经网络，现在你有兴趣用它来解决一个问题。让我们探索一下如何使用我们可以使用的不同工具来建模一个问题。
来自 Pexels 的照片
首先，我们需要解决一个问题。
开始使用。
让我们挑选一个简单的图形数据集，比如扎卡里的空手道俱乐部。这里，节点代表参与俱乐部的 34 名学生，链接代表俱乐部外成对成员之间的 78 种不同互动。有两种不同类型的标签即两派。我们可以使用这些信息来制定节点分类任务。
我们将图分为训练集和测试集，其中我们使用训练集来构建图神经网络模型，并使用该模型来预测测试集中的缺失节点标签。
这里我们用 PyTorch 几何 (PyG) python 库来建模图形神经网络。或者，深度图形库 (DGL)也可以用于同样的目的。
PyTorch Geometric 是一个基于 PyTorch 构建的几何深度学习库。已经使用 PyG 实现了几种流行的图形神经网络方法，您可以使用内置数据集来研究代码，或者创建自己的数据集。PyG 使用了一个漂亮的实现，它提供了一个 InMemoryDataset 类，可以用来创建自定义数据集(注意:InMemoryDataset 应该用于小到足以加载到内存中的数据集)。
Zachary 的空手道俱乐部图表数据集的简单可视化如下所示:
扎卡里空手道俱乐部图形数据可视化(来源:me)
公式化问题。
为了阐明这个问题，我们需要:
- 图形本身和每个节点的标签
- 坐标格式的边缘数据(首席运营官)
- 节点的嵌入或数字表示
注意:对于节点的数字表示，我们可以使用图的属性，如度，或者使用不同的嵌入生成方法，如 node2vec 、 DeepWalk 等。在这个例子中，我将使用节点度作为它的数字表示。
让我们进入编码部分。
准备工作。
空手道俱乐部数据集可以直接从 NetworkX 库中加载。我们从图中检索标签，并以坐标格式创建边索引。节点度被用作节点的嵌入/数字表示(在有向图的情况下，入度可以用于相同的目的)。由于学位值往往是多种多样的，我们在使用这些值作为 GNN 模型的输入之前对它们进行归一化。
至此，我们已经准备好了构建 Pytorch 几何自定义数据集的所有必要部分。
自定义数据集。
KarateDataset 类继承自 InMemoryDataset 类，并使用一个数据对象来整理与空手道俱乐部数据集相关的所有信息。然后将图形数据分割成训练集和测试集，从而使用分割创建训练和测试掩码。
数据对象包含以下变量:
数据(edge_index=[2，156]，num_classes=[1]，test_mask=[34]，train_mask=[34]，x=[34，1]，y=[34])
这个自定义数据集现在可以与 Pytorch 几何库中的几个图形神经网络模型一起使用。让我们挑选一个图卷积网络模型，并使用它来预测测试集上的缺失标签。
注意:PyG 库更侧重于节点分类任务，但它也可以用于链接预测。
图卷积网络。
GCN 模型由两个隐层构成，每个隐层包含 16 个神经元。让我们训练模型！
训练 GCN 模型。
随机超参数的初始实验给出了这些结果:
训练精度:0.913
测试精度:0.727
这并不令人印象深刻，我们当然可以做得更好。在我的下一篇文章中，我将讨论我们如何使用 Optuna (关于超参数调优的 python 库)来轻松地调优超参数并找到最佳模型。本例中使用的代码取自 PyTorch Geometric 的 GitHub 库，并做了一些修改(链接)。
总结。
总结一下我们到目前为止所做的一切:
- 为图中的每个节点生成数字表示(在本例中为节点度数)。
- 构建一个 PyG 自定义数据集，并将数据分为训练和测试两部分。
- 使用像 GCN 这样的 GNN 模型并训练该模型。
- 对测试集进行预测，并计算准确度分数。
鸣谢:
这篇文章中的大部分解释都是我在 Cesson-sévigne 的 Orange Labs 实习期间学到并应用的概念。我研究过图形嵌入方法，也研究过可以应用于知识图的图形神经网络。
在接下来的部分中，我将更多地解释我们如何使用图嵌入作为初始节点表示来处理相同的节点分类任务。
感谢阅读，干杯！
**Want to Connect?**Reach me at [LinkedIn](https://www.linkedin.com/in/rohithteja/), [Twitter](https://twitter.com/rohithtejam), [GitHub](https://github.com/rohithteja) or just [Buy Me A Coffee](https://www.buymeacoffee.com/rohithteja)!
使用 PyTorch 几何图形的神经网络初学者指南—第 2 部分
使用深度行走嵌入作为我们的 GNN 模型的输入特征。
在我之前的帖子中，我们看到了 PyTorch 几何库如何用于构建 GNN 模型，并在 Zachary 的空手道俱乐部数据集上制定节点分类任务。
语境。
图形神经网络模型需要初始节点表示来进行训练，之前，我采用节点度数作为这些表示。但有几种方法可以做到这一点，另一种有趣的方法是使用基于学习的方法，如节点嵌入作为数字表示。
回顾:空手道俱乐部数据集。
空手道俱乐部数据可视化(来源:作者)
这是数据集及其可视化的一个小总结，用两种不同的颜色显示了两个派别。
数据集:扎卡里空手道俱乐部。
这里，节点代表参与俱乐部的 34 名学生，链接代表俱乐部外成对成员之间的 78 种不同互动。有两种不同类型的标签即两派。
节点嵌入。
我们的想法是使用一组称为低维嵌入的数字来捕获网络信息。存在专门用于学习图节点的数字表示的不同算法。
DeepWalk 是一种基于随机行走概念的节点嵌入技术，我将在本例中使用。为了实现它，我选择了图形嵌入 python 库，它提供了 5 种不同类型的算法来生成嵌入。
首先，安装图形嵌入库并运行安装程序:
!git clone https://github.com/shenweichen/GraphEmbedding.gitcd GraphEmbedding/!python setup.py install
我们使用深度行走模型来学习我们的图节点的嵌入。变量embeddings以字典的形式存储嵌入，其中键是节点，值是嵌入本身。
正如我之前提到的，嵌入只是网络的低维数字表示，因此我们可以对这些嵌入进行可视化。这里，嵌入的大小是 128，所以我们需要使用 t-SNE ，这是一种降维技术。基本上，t-SNE 将 128 维数组转换成 2 维数组，这样我们就可以在 2D 空间中将其可视化。
注意:嵌入大小是一个超参数。
使用上述代码制作的可视化效果如下所示:
节点嵌入的可视化(来源:作者)
我们可以看到，为该图生成的嵌入具有良好的质量，因为红点和蓝点之间有清晰的分离。现在，我们可以建立一个图形神经网络模型，在这些嵌入上进行训练，最后，我们将有一个好的预测模型。
我将重用我之前的帖子中的代码来构建节点分类任务的图形神经网络模型。我们现在遵循的程序与我之前的帖子非常相似。我们只是将节点特征从 DeepWalk 嵌入改为 deep walk 嵌入。
数据准备。
这里，我们只是准备将在下一步中用于创建自定义数据集的数据。请注意我如何更改了保存从 DeepWalk 算法生成的节点嵌入值的embeddings变量。
自定义数据集。
为了将结果与我之前的帖子进行比较，我使用了与之前类似的数据分割和条件。
数据对象现在包含以下变量:
Data(edge_index=[2，156]，num _ class =[1]，test_mask=[34]，train_mask=[34]，x=[34，128]，y=[34])
我们可以注意到x变量的维数从 1 到 128 的变化。
图卷积网络。
我们使用相同的代码来构建图形卷积网络。
现在是时候训练模型并在测试集上进行预测了。
训练 GCN 模型。
使用与之前相同的超参数，我们获得如下结果:
训练精度:1.0
测试精度:0.90
这是一个巨大的进步！
推论。
从结果中可以看出，当 GNN 模型在第 1 部分的类似条件下进行训练时，我们实际上在训练和测试准确性方面都有了很大的提高。
注意:我们当然可以通过进行超参数调整来改善结果。
这表明当我们使用基于学习的节点嵌入作为输入特征时，图形神经网络表现得更好。现在问题来了，为什么会这样？
回答这个问题需要一点解释。所以我会写一篇新的帖子来解释这种行为。敬请期待！
参考文献。
- PyTorch 几何:【https://github.com/rusty1s/pytorch_geometric
- 深度行走:【https://arxiv.org/abs/1403.6652
- 图形嵌入库:https://github.com/shenweichen/GraphEmbedding
- GCN 代码示例:https://github . com/rusty 1s/py torch _ geometric/blob/master/examples/gcn . py
5.链接到本系列的第 1 部分。我强烈建议看看这个:
我希望你喜欢阅读这篇文章，你可以在 LinkedIn、 Twitter 或 GitHub 上找到我。随便打个招呼吧！
Hadoop 基础入门指南
Hadoop 大数据分析平台及其主要模块的非技术性介绍
从字面上看，Hadoop 是一只玩具大象的名字——确切地说，是 Doug Cutting(Hadoop 的联合创始人)的儿子的玩具大象。但是，您在这里不是为了了解 Hadoop 是如何或从哪里得名的！从广义上讲，Hadoop 是一个通用的、类似操作系统的并行计算平台。
我相信，在处理我们周围的所有大数据时，我不需要提到单个系统的严重局限性——这完全超出了单台机器的处理能力。Hadoop 提供了一个框架，通过并行处理来处理这些大数据，类似于超级计算机的用途。
但是，为什么我们不能利用超级计算机来并行处理大数据:
- 超级计算机没有标准化的操作系统(或类似操作系统的框架)——这使得中小型组织更难使用它们
- 初始购买和定期维护的成本都很高
- 硬件支持依赖于特定的供应商，也就是说，公司不能从不同的供应商那里采购各种单独的组件，然后将它们放在一起
- 在大多数情况下，需要开发定制软件来基于特定用例操作超级计算机
- 不容易横向扩展
Hadoop 解决了上述所有限制:它是一个开源(具有强大的社区支持和定期更新)、类似操作系统的并行处理平台，不依赖特定硬件供应商的持续硬件支持(与商用硬件配合使用)，也不需要任何专有软件。
自 2006 年以来，Hadoop 已经发布了三个稳定版本:Hadoop 1、Hadoop 2 和 Hadoop 3。
现在让我们更详细地看看 Hadoop 的架构，我将从 Hadoop 1 开始，这将使我们稍后更容易理解 Hadoop 2 的架构。我还将假设对以下术语有一些基本的熟悉:商用硬件、集群&集群节点、分布式系统和热备用。
Hadoop 1 架构
以下是 Hadoop 1 体系结构的主要物理组件:
主节点:
- 名称节点:Hadoop 的集中式文件系统管理器，它跟踪数据文件被分成的块数、块大小以及哪些数据节点将保存和处理每个文件块，而不保存任何数据
- 辅助名称节点:名称节点的备份，但不处于热备用状态
- 作业跟踪器:Hadoop 的集中式作业调度器，负责调度数据节点上作业的执行
上述每个节点代表生产环境中的一台机器，以主模式工作，通常放置在生产设置的不同机架中(以避免一个机架故障导致多个主节点停机)。
从节点:
- 数据节点:存储和处理数据块形式的工作文件的独立机器/系统
- 任务跟踪器:一种软件服务，用于监控作业跟踪器的状态，跟踪数据节点正在执行的活动，并向作业跟踪器报告状态。每个数据节点一个任务跟踪器
从节点在没有主节点的情况下不能工作，并且完全依赖于它们在进行任何种类的处理活动之前从主节点接收的指令。为了确保连续的正常运行时间，从节点每三秒钟向名称节点发送一次心跳信号，以确认它们已经启动并处于活动状态。
所有上述主节点和从节点通过网络基础设施相互连接，形成一个集群。
就处理能力而言，Job Tracker 比 Name 和 Secondary Name 节点更强大，而且都不需要大量的存储容量。然而，数据节点是集群中最强大的机器，具有大量 RAM 和处理能力。
部署模式
以下是 Hadoop 支持的三种主要部署或配置模式:
- 独立模式:所有 Hadoop 服务(即每个名称节点、辅助名称节点、作业跟踪器和数据节点)都在单个 Java 虚拟机(JVM)内的单个机器上本地运行。然而，现在很少使用独立模式
- 伪分布式模式:所有 Hadoop 服务都在一台机器上本地运行，但是在不同的 JVM 中运行。伪分布式模式通常在开发和测试活动中使用，并且用于教育目的
- 完全分布式模式:在生产设置中使用，其中所有 Hadoop 服务都在单独的专用机器/服务器上运行
Hadoop 中的作业是什么？
Hadoop 生态系统中的作业类似于 Python 脚本/程序，用户可以执行该脚本/程序来执行特定的任务。就像 Python 脚本一样，Hadoop 的工作是一个程序(通常是一个 JAR 文件),它被提交到 Hadoop 集群，以便对驻留在数据节点上的输入(原始)数据进行处理和执行，处理后的输出保存在指定的位置。
Hadoop 的软件组件
现在让我们从 Hadoop 的物理基础设施转移到它的软件组件。Hadoop 的核心软件组件包括:
- 用于数据存储和检索的 Hadoop 分布式文件系统(HDFS)
- MapReduce 是一个基于 Java 的并行处理框架，是 Hadoop 的编程部门，用于处理 HDFS 提供的数据
MapReduce 还包括:
- 用户定义的映射阶段，执行输入数据的并行处理
- 用户定义的缩减阶段，汇总映射阶段的输出
需要明确的是，Hadoop 是一个并行处理平台，它提供硬件和软件工具来实现并行处理，然后提供 MapReduce 框架(即一个可以根据用户需求定制的基本框架)来进行并行处理。但是 MapReduce 不是 Hadoop 支持的唯一框架——Spark 是另一个。
Hadoop 分布式文件系统(HDFS)
HDFS 是 Hadoop 生态系统的文件管理组件，负责存储和跟踪跨各种数据节点的大型数据集(结构化和非结构化数据)。
为了理解 HDFS 的工作原理，让我们考虑一个大小为 200MB 的输入文件。如前所述，为了促进数据节点上的并行处理，这个单个文件将被分解成多个块并保存在数据节点上。
HDFS 的默认分割大小(这是一个全局设置，可以由 Hadoop 管理员配置)是 64MB。因此，我们的 200MB 样本输入文件将被分成 4 个块，其中 3 个块为 64MB，第 4 个块为 8MB。HDFS 负责将输入文件分割成单独的块，并保存在特定的数据节点上。
这里需要注意的一个关键方面是，HDFS 对输入文件的拆分发生在 Hadoop 集群之外的客户端机器上，名称节点根据特定算法决定每个数据块在特定数据节点中的放置。因此，一旦名称节点向客户机提供了数据块放置策略，客户机就直接将数据块写入数据节点。
名称节点充当一本书的目录，它记住各个名称节点中每个数据块的位置，以及其它信息，例如块大小、主机名等。，在一个称为文件系统映像(FS 映像)的文件表中。
数据节点的故障管理
那么，如果数据节点出现故障，会发生什么情况呢？甚至一个数据节点的故障都会导致整个输入文件被破坏——因为我们的拼图中有一块已经丢失了！在典型的生产设置中，我们通常处理数百 GB 的数据块，将原始数据文件推回 Hadoop 集群效率非常低，而且非常耗时。
为了避免任何潜在的数据丢失，每个数据节点上的数据块的备份副本被保存在相邻的数据节点上。每个数据块的备份副本数量由复制因子控制。默认情况下，复制系数设置为 3，即每个数据节点上的每个数据块都保存在 2 个额外的备份数据节点上，因此 Hadoop 集群将拥有每个数据块的 3 个副本。在将源数据文件推送到 HDFS 时，可以基于每个文件配置此复制因子。
一旦任何数据节点未能向名称节点发送心跳信号，备份数据节点就会开始工作。备份数据节点启动并运行后，名称节点将启动数据块的另一个备份，以便复制因子 3 在整个群集中保持不变。
次要名称节点
在 Hadoop 1.0 中，辅助名称节点充当名称节点的文件系统映像的备份。然而，这是 Hadoop 1.0 的主要限制之一，辅助名称节点不能在热备用模式下运行。因此，在名称节点出现故障的情况下，整个 Hadoop 集群将停止运行(数据将存在于数据节点中，但是，由于集群丢失了文件系统映像，数据将不可访问)，并且需要将辅助名称节点的内容手动复制到名称 Nome。
我们稍后将讨论这个问题，但是随着 Hadoop 2.0 的发布，这个问题得到了解决，在 Hadoop 2.0 中，辅助名称节点充当热备用。
Hadoop 2.0
Hadoop 2.0 有时也被称为 MapReduce 2 (MR2)或另一种资源协商器(YARN)。
让我们试着理解 Hadoop 1.0 和 Hadoop 2.0 之间显著的架构差异。请记住，在 Hadoop 1.0 中，作业跟踪器充当集中式作业调度程序，它将特定作业拆分为多个作业，然后将它们传递给各个数据节点，其中数据节点上的各个任务由任务跟踪器监控，然后任务跟踪器将状态报告给作业跟踪器。除了其作业调度职责之外，作业跟踪器还以静态模式(即，系统资源不是动态的)将系统资源分配给每个数据节点。
Hadoop 2.0 用 YARN 替换了作业跟踪器，而底层文件系统仍然是 HDFS。除了 MapReduce，YARN 还支持其他并行处理框架，例如 Spark。YARN 还可以支持多达 10，000 个数据注释，而 Hadoop 1.0 的作业跟踪器仅支持 4，000 个数据节点。
YARN 有两个组件:调度程序和应用程序管理器。这两项任务都由 Hadoop 1.0 中的作业跟踪器单独管理。将这些不同的职责分离到 YARN 的各个组件中，可以更好地利用系统资源。
此外，在 Hadoop 2.0 中，每个数据节点上的任务跟踪器被单个节点管理器(以从属模式工作)所取代。节点管理器直接与 YARN 的应用程序管理器通信，进行资源管理。
正如前面提到的，除了一个辅助名称节点，Hadoop 2.0 还有一个热备用名称节点，在名称节点出现故障的情况下，它可以无缝地投入使用。在名称和热备用名称节点都出现故障的情况下，备用名称节点就派上了用场。
什么是 MapReduce？
顾名思义，MapReduce 由以下两个阶段组成，每个阶段又有 3 个子阶段:
地图阶段
映射阶段的所有 3 个子阶段都在驻留在各个数据节点中的每个数据块中执行或操作，这是 Hadoop 中并行化的切入点。
记录阅读器
记录阅读器被预编程为一次处理输入文件中的一行，并产生 2 个输出:
- 钥匙:一个数字
- 值:整行
制图师
Mapper 是可编程的，可以根据任何所需的逻辑或问题陈述，一次一个地处理记录读取器输出的每个键值对。它根据用户定义的功能输出额外的键值对。
分拣机
Mapper 的输出被输入到按字典顺序排序的排序器中(很明显！😊)映射器输出的关键字。如果关键字是数字，那么分类器将执行数字分类。分类器是预编程的，唯一可能的配置是对值进行分类。
减少阶段
在映射阶段的最后，我们将有多个映射器输出，每个数据节点一个。所有这些输出都将被传输到一个单独的数据节点，在那里将对它们执行 Reduce 操作。
归约操作的 3 个子阶段是:
合并
来自每个映射操作的中间输出被附加到另一个上，以产生单个合并文件。
洗牌机
Shuffler 是另一个预编程的内置模块，它将输入中出现的重复键聚集在一起，产生每个唯一键的值列表。
减速器
Shuffler 的输出被馈送到 Reducer，它是 Reduce 阶段的可编程模块，类似于 Mapper。Reducer 根据问题陈述中编程执行的内容，以键值对的形式产生输出。
实际例子
我将使用一个非常简单的非 ML 问题陈述来尝试和解释 MapReduce 的机制和工作流程。考虑一个只有如下两条语句的输入文件:
Processing big data through Hadoop is easy
Hadoop is not the only big data processing platform
我们的任务是找到输入文件中单词的频率，预期的输出是:
Processing 2
big 2
data 2
through 1
Hadoop 2
is 2
easy 1
not 1
the 1
only 1
platform 1
经历上面解释的 MapReduce 阶段:
- Record Reader 读取第一行后的输出将是:
Key: 0(文件/行偏移量—起始位置)
Value:通过 Hadoop 处理大数据很容易 - 我们可以对映射器进行如下编程:
步骤 1:忽略输入键
步骤 2:从行中提取每个单词(标记化)
步骤 3:以键-值对的形式生成输出，其中键是行中的每个单词，值是该单词在输入行中的频率
相应地，在处理两行之后，映射器的输出将如下所示:
Processing 1
big 1
data 1
through 1
Hadoop 1
is 1
easy 1
Hadoop 1
is 1
not 1
the 1
only 1
big 1
data 1
processing 1
platform 1
- 排序器的输出将是这样的:
big 1
big 1
data 1
data 1
easy 1
Hadoop 1
Hadoop 1
is 1
is 1
not 1
only 1
platform 1
processing 1
Processing 1
the 1
through 1
- Shuffler 的输出将是这样的:
big 1, 1
data 1, 1
easy 1
Hadoop 1, 1
is 1, 1
not 1
only 1
platform 1
processing 1, 1
the 1
through 1
- Reducer 可以被编程来执行以下操作:
步骤 1:从 Shuffler 的输出
中获取键值对步骤 2:将每个键的列表值相加
步骤 3:输出键值对，其中键保持不变，并且值是 Shuffler 的输出
列表中的数字之和步骤 4:对从 Shuffler 接收的每个键值对重复上述步骤
相应地，Reducer 的输出将是:
big 2
data 2
easy 1
Hadoop 2
is 2
not 1
only 1
platform 1
processing 2
the 1
through 1
MapReduce 的使用案例
MapReduce 的某些行业用例包括:
- 在大数据集中搜索关键词
- 谷歌将其用于字数统计、广告词、页面排名、谷歌搜索的索引数据、谷歌新闻的文章聚类(最近谷歌已经从 MapReduce 上转移)
- 文本算法，如 grep、文本索引、倒排索引
- 数据挖掘技术
- 脸书将其用于数据挖掘、广告优化、垃圾邮件检测
- 金融服务提供商的分析
- 批量、非交互式分析
结论
是的，这是对 Hadoop 和 MapReduce 世界的一个非常高级的非技术性介绍。显然，还有几个其他的 Hadoop 组件我在这里没有涉及到，例如，Hive、Zookeeper、Pig、HBase、Spark 等等。
如果您想讨论上述内容，或者我以前的任何帖子中的内容，或者任何与数据分析、机器学习和金融风险相关的内容，请随时联系我。
下次见，摇滚起来！
机器学习中图像增强的初学者指南
马库斯·斯皮斯克在 Unsplash 上的照片
数据扩充是机器学习系统中最重要但被低估的方面之一，对模型的性能有着重要的影响。在本文中，我们将回顾一些流行的图像增强技术，并讨论为什么首先需要这些方法。
我们将尝试回答各种问题，例如:为什么图像增强对于任何机器学习管道都是必要的？实现目标的技术是什么？我们如何使用 python、OpenCV 和 NumPy 来使用这些技术呢？
为什么有必要？
首先，我们应该问问自己，数据增强是否值得我们花时间去做。简单的回答是“有”，原因多种多样，比如训练数据量小，避免过拟合，还有很多其他原因。下面给出更详细的讨论:
- 缺乏广泛的训练数据:- 在许多场景中，例如在医学领域，获取数据很困难(由于严格的法规)，而且成本高昂，而标记数据的成本更高。在所有这些情况下，使用数据扩充技术人工生成更多的训练数据变得越来越重要。
- 避免过度拟合:- 对少量数据进行训练的一个重要意义是过度拟合的可能性。当模型被认为已经记住了训练数据，使得它在训练数据上表现得更好，而在看不见的测试数据上表现得很差时，就会发生过拟合。在这种情况下，数据量被人为地增加，以迫使模型从许多场景中学习，从而减少过度拟合的机会。
- 包括数据的多样性:- 以 MNIST 数据集为例，我们可以认为，对于数据中的所有 60000 位数字，所有数字都位于图像的中心，并且完全水平。如果部署一个根据这些数据训练的系统来识别现实生活场景中的数字，它将会悲惨地失败，因为许多数字都是倾斜的。所以，必须修改它，使所有这样的用例减少系统的错误。在这种情况下，我们可以旋转图像以扩展数据集，并在扩展的数据集上进行训练以提高性能。
我们已经在本节讨论了数据扩充的必要性。在下一节中，我们将继续讨论使用 python 代码的各种图像增强技术。
各种图像增强技术有哪些？
在本节中，我们将继续讨论一些广泛使用的数据扩充技术。除此之外，我们还要回答一些问题，比如为什么我们需要一个特定的方法，这个方法如何改善结果，还有代码和一个图像示例。
我们已经讨论了诸如模糊、噪声添加、调整大小、随机裁剪、中心裁剪、直方图均衡化、翻转、旋转和归一化等技术。在这些技术之后，我们将深入一些更高级的技术，如剪切混合、剪切和混合。
虚化
在许多情况下，数据集图像通常是在最佳照明条件下用最佳摄像设备拍摄的，以获得最佳质量的数据集。但是在现实生活中，情况往往并非如此，常常会导致糟糕或误导性的结果。因此，使用蓝色和其他噪声添加技术来降低数据集的质量，以引入缺陷，从而使机器学习模型对现实生活中的例子更加鲁棒。
模糊图像的代码。
图像和模糊图像。( Unsplash
噪声添加
如前一段所述，需要降低数据集的质量，使用了噪声添加和模糊等技术。除此之外，为了模拟相机传感器，通常将噪声添加到图像中以训练去噪模型。
密度估计用于模拟图像的概率分布，这些图像通常在本质上是量化的。神经网络假设分布是连续的，因此以连续形式转换图像是必要的。因此，在许多情况下，如 VAE，数据中经常会加入归一化流量噪声。噪声添加的一个例子可以看做如下:
用于在图像中添加噪声的代码。
添加噪声后的结果图像(真实图像在右下方)
调整大小
调整大小是一种图像处理操作，通常用于改变图像的大小。它有多种用途，例如维护数据集的大小一致性、减少内存消耗(大图像消耗更多内存)、改善延迟等。
有各种技术来执行图像尺寸调整，例如双线性插值、最近邻插值、双三次插值、分形插值、克里金技术等。这些技术产生具有细微差别的高质量图像，除非我们更仔细地观察图像，否则通常是看不到的。
( Unsplash
随机裁剪(随机调整裁剪大小)
随机裁剪是在图像中随机裁剪图像的一部分的技术。这样做是为了在训练期间引入正则化，并减少模型中的过拟合。它通常在训练时应用，因此模型不会两次得到相同的图像。它有助于更好地推广该模型。随机裁剪增加了训练数据的数量，有助于模型更好地概括，并在数据中引入多样性。
( Unsplash
( Unsplash
( Unsplash )
中间作物
像随机裁剪一样，这种技术也用于裁剪图像。中心裁剪和随机裁剪的主要区别在于，前者的裁剪只在图像的中心进行。这种技术用于图像的中心部分比角部包含更多信息的情况，因此为了迫使模型从图像的中心部分而不是角部学习，使用这种技术。
(不飞溅)
直方图均衡
简而言之，它是一种通过使用直方图来扩展像素强度值以调整图像对比度的技术。在许多低对比度的图像中，亮区和暗区相互重叠，产生了缺乏质量和照明的图像。缺乏对比往往导致模型缺乏概括性。因此，图像中应该有足够的对比度来区分亮区和暗区。
( Unsplash )
水平/垂直翻转
这种技术用于在训练过程中增加数据集的大小，通常随机应用于图像，以减少过度拟合并在数据中引入多样性。每当使用这种技术时，通常假设标签是不变的或者可以被变换。例如，在分割中，遮罩也可以翻转。同时，采用这种技术，但不采用数字识别，因为翻转的数字将具有不同的含义，并导致完全错误的模型。
( Unsplash
旋转
应用旋转来训练模型，以避免过度拟合和在数据中引入多样性。旋转相对于翻转的主要优点是，如果应用到一定程度，例如在[-45，+45]范围内，它不会完全改变数据的含义。此外，当在训练期间随机应用旋转时，它还有一个额外的优点，即模型永远不会看到同一个图像两次。
( Unsplash
正常化
该技术用于在训练模型之前标准化像素的范围和顺序。这样做通常是为了保持不同数据集的一致性。例如，一些数据集可能有 8 位图像，而一些可能有 16 位图像。如果模型直接针对它们进行训练，就会产生问题。因此，在训练之前标准化图像是至关重要的。可以采用最小-最大缩放、z 分数等技术来实现这一目的。
断流器
剪切指的是一种技术，其中图像的重要部分被模糊化，随机应用于输入图像，以充当正则化并因此改进模型。这种技术类似于丢弃，即输入的特定部分被随机设置为零，以阻止跨层的信息流。在各种计算机视觉任务中，例如物体检测、人体姿态估计等，剪切块也用于模拟物体遮挡情况。还可以看出，即使在遮挡不是问题的情况下，使用剪切也可以提高模型的准确性。
( Unsplash
剪切混合
在这种策略中，不同图像的补丁被随机剪切并粘贴在一起，以使数据规则化。地面实况标签也以加权方式组合，其权重与小块的面积成比例。这种技术相当于区域剔除，因此相当于数据正则化技术。这种技术的主要优点是图像中没有像抠图那样的空像素。通过强制模型从补丁而不是整个图像中学习，使用补丁增加了模型定位信息的能力。
( Unsplash )
混合
在 MixUp 中，通过添加(混合)2 个或更多图像来产生新图像，从而创建新图像。地面标记也以相同的方式使用阈值作为权重进行组合。
(不飞溅)
结论
在本文中，我们讨论了一些流行的图像增强技术。在 python 中实现这些技术时，除了 numpy、OpenCV 之外，没有其他库用于以详细的方式完成该过程，同时也理解该过程的本质。但是，建议使用流行的图像增强库，如 torchvision、albumentations 等。，同时编码深度神经网络以节省时间和避免 bug。我们本可以在本文中讨论更多的技术，但是本文的目标是理解图像增强的需求并正确地应用它。
感谢你阅读这篇文章直到最后。欢迎在评论区讨论这个问题。
Python 机器学习初学者指南
任何数据科学项目的入门代码、说明和学习资源
米利安·耶西耶在 Unsplash 上拍摄的照片
为什么要跟着机器学习教程一起编码？
有两种方法可以用来研究任何主题——自上而下和自下而上。
当你在学校学习像数学和科学这样的科目时，你会被教授自下而上的方法。
首先，你被教授了题目的基础，然后通过材料逐渐进步。
然而，当学习像数据科学和机器学习这样的学科时，自上而下的方法往往更容易掌握——尤其是如果你没有很强的数学背景。
使用自顶向下的方法，您可以首先通过实现机器学习模型来弄脏您的手。
这很容易做到，因为 Python 和 r 等语言中有很多可用的包。
机器学习的民主化让你可以创建端到端的机器学习模型，而无需了解它们如何工作以及算法背后的数学。
当然，你仍然需要了解这些算法是如何工作的，但这可以在以后(一旦你学会了如何在实践中建立这些模型)。
介绍
在这篇文章中，我将带你通过 Kaggle 上的 Pima Indian 糖尿病数据集完成一个端到端的机器学习项目。
我将为数据预处理、分析、模型训练和评估提供代码。你可以用它作为你将来从事的任何机器学习项目的起始代码。
我还将为我使用的每种技术和算法提供额外的学习资源，这样您就可以阅读它们并更好地理解它们的工作原理。
注:
我已经做过一个关于同一数据集的数据分析教程，这个你可以在这里 查阅 。因此，在本文中，我不会过多地讨论数据分析和可视化的细节。相反，我将把更多的注意力放在构建机器学习算法上。
先决条件
亚历克斯·丘马克在 Unsplash 上的照片
要继续学习本教程，您需要在计算机上安装 Python IDE。
我建议使用 Jupyter 笔记本，因为我就是用它来创建本教程的，而且 Jupyter 允许您在代码所在的同一文档中显示可视化效果。
你还需要预装以下软件包——熊猫、 Numpy 、 Matplotlib 、 Seaborn 和 Scikit-Learn 。按照文档中的说明安装这些库。
步骤 1:读取数据
这个是我们将在整个教程中使用的数据集。下载并准备好环境后，运行以下代码行:
# importsimport numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns# Reading the data-framedf = pd.read_csv('pima.csv')
步骤 2:探索性数据分析
读取数据框后，运行以下代码行查看不同的变量:
df.head()
您将看到以下输出:
数据帧中的不同变量包括:
- 怀孕——怀孕次数
- 葡萄糖——口服葡萄糖耐量试验中 2 小时的血浆葡萄糖浓度
- 血压——舒张压
- 皮肤厚度——三头肌皮褶厚度
- 胰岛素— 2 小时血清胰岛素
- 身体质量指数——身体质量指数
- 糖尿病谱系功能——糖尿病谱系功能
- 年龄-年龄
- 结果——患者是否患有糖尿病
结果变量是我们的目标，所有其他变量都是预测变量。我们需要使用剩余的变量来预测机器学习模型的结果。
要查看一些描述性统计数据，请运行以下代码行:
df.describe()
我们可以看到一些简单的数据集统计数据:
作者图片
现在，我们可以运行几行代码来查看数据集中所有变量之间的关系:
# pairplot:
sns.pairplot(df,hue='Outcome')
渲染出以下情节:
*因为太大了 我没有包括整个图像
结对图是非常有用的可视化工具。它允许您一次查看数据集中所有变量之间的关系。
乍一看，您将能够注意到突出的变量之间的强关系。然后，您可以继续检查这些关系，并移除可能导致模型中出现多重共线性的高度相关的属性。
第三步:数据预处理
现在，我们可以检查数据框中缺失的值:
print(df.isnull().values.any())
上面的行应该返回 False。数据框中没有缺失值。
现在，我们将标准化我们的变量，使它们都在相同的范围内。你可以在这里阅读更多关于标准化为何重要的信息。如果你喜欢看而不是读，我建议看一看克里斯·纳伊克关于特征缩放重要性的解释。
我们将做一些叫做 Z 分数标准化的事情。这将采用我们所有的变量，并将其转换为服从均值为 0、标准差为 1 的正态分布。
运行以下代码行:
X = df.drop('Outcome',axis=1)
y = df['Outcome']# standardization
X = (X-X.mean())/X.std()
完成后，再次检查数据帧的头部:
X.head()
转换后的数据框将如下所示:
现在我们已经完成了数据预处理，我们可以开始构建机器学习模型了。
第四步:机器学习模型
首先，我们需要将数据帧分成训练集和测试集。我们将在一组数据上训练该模型，然后在它从未见过的数据上评估它的性能。
有许多方法来执行模型验证，其中最流行的是 K-fold 交叉验证。你可以在这里阅读不同的交叉验证方法。
然而，我将在本文中介绍最简单的验证方法——将数据集分成两部分，保留一组数据进行测试。
下面是实现这一点的一些代码:
from sklearn.model_selection import train_test_splitX_train,X_test,y_train,y_test = train_test_split(X,y,test_size = 0.25)
这样做之后，我们将获得单独的数据集来训练和测试我们的模型。我们现在可以开始创建模型了。
逻辑回归分类器
我们将建立的第一个模型是逻辑回归分类器。该模型将逻辑函数拟合到数据上，以识别每个数据点所属的类别。
如果你学过线性回归，你应该知道逻辑回归使用相同的线性函数(y=a+bX)来分离每个类的值。然而，它稍微修改了线性函数，使得值不会低于 0 或高于 1。
因此，逻辑回归分类器输出概率。默认情况下，模型预测是概率最高的类。
您可以通过根据自己的需要定制逻辑回归模型的阈值来更改这一点。默认情况下，该值为 0.5。在本教程中，我们将使用默认阈值 0.5。
如果你想了解更多关于逻辑回归的知识，我建议你看一下这个视频。
您可以运行以下代码行来将逻辑回归模型拟合到定型数据中:
from sklearn.linear_model import LogisticRegressionlr = LogisticRegression()
lr.fit(X_train,y_train)
现在，我们可以根据测试数据做出预测:
lr_preds = lr.predict(X_test)
我们完事了。现在，我们可以在下一个模型上拟合数据。
决策树分类器
决策树分类器是一种基于树的模型。它将获取数据集中的所有变量，并对它们进行分割。
在每次分割时，它要么将数据点分配给一个类，要么在不同的变量上进行分割。此过程会一直持续，直到不再有要分割的要素，或者达到停止标准。
决策树分类器通过选择在每次分割时损失最小的特征来决定分割什么。基尼指数和熵是决策树分类器中常用的两种损失函数。
你可以观看这段视频，更好地了解决策树是如何工作的。
要使决策树分类器适合数据，请运行以下代码行:
from sklearn.tree import DecisionTreeClassifier
dt = DecisionTreeClassifier()dt.fit(X_train,y_train)
让我们使用这个模型对测试数据进行预测:
dt_preds = dt.predict(X_test)
搞定了。让我们继续下一个模型。
随机森林分类器
随机森林模型使用多个决策树来进行预测。在实践中，随机森林通常优于决策树和线性分类器。
它使用了一种叫做 bagging 的技术，代表引导聚合。训练数据集被随机采样多次，决策树被拟合到每个数据样本上。
在每个节点上，只考虑要素的子集进行划分，以确保模型中每个变量的公平表示。
在像这样的分类问题中，输出是所有决策树的多数类预测。
要了解更多关于随机森林算法的工作原理，你可以阅读这篇文章。如果你视觉学得更好，你可以看这个视频。
运行以下代码行，以使随机森林分类器适合定型集:
from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier()rf.fit(X_train,y_train)
现在，运行下面的代码对测试集进行预测:
rf_preds = rf.predict(X_test)
搞定了。让我们继续讨论我们将在本教程中构建的最终模型。
XGBoost 分类器
XGBoost 分类器是基于树的模型的另一种扩展，它使用一种称为 boosting 的技术来提高决策树的性能。
梯度推进算法的工作方式非常直观。首先实现一个基础学习器来进行初始预测。计算初始模型的残差，并添加预测初始模型残差的第二决策树。
就像这样，增加一个决策树链，形成一个序列模型，使整体残差最小化。
要了解更多关于梯度推进，你可以观看这个视频。
梯度推进是最流行的监督学习技术之一，它经常被数据科学家用于 Kaggle 竞赛。实际上，它们的表现往往比决策树好得多。
from xgboost import XGBClassifier
xgb = XGBClassifier()xgb.fit(X_train,y_train)
现在，运行这些代码行来对测试集进行预测:
xgb_preds = xgb.predict(X_test)
就是这样！我们已经完成了模型的训练并保存了它们的预测。现在让我们来看看模型性能。
第五步:评估
我们将看看用于评估模型性能的最简单的度量标准——准确性。
以下代码行将创建一个条形图，显示所有四个模型的准确性得分:
model = np.array(['Logistic Regression','Decision Tree','Random Forest','Gradient Boosting'])from sklearn.metrics import accuracy_scorescores = np.array([accuracy_score(lr_preds,y_test),accuracy_score(dt_preds,y_test),accuracy_score(rf_preds,y_test),accuracy_score(xgb_preds,y_test)])df = {'model': model, 'scores': scores}
sns.barplot(x='model',y='scores',data=df)
这些代码行将呈现一个如下所示的图表:
每个模型的精度如下:
- 逻辑回归— 0.73
- 决策树分类器— 0.77
- 随机森林分类器— 0.81
- XGBoost 分类器— 0.79
看起来随机森林分类器已经胜过了其他模型，XGBoost 紧随其后。
请记住，当您运行相同的代码行时，您的结果可能与我的略有不同，因为每次您进行训练测试分割时，数据将被不同地分区。
此外，您还需要记住其他重要的分类指标，以确保您的模型性能良好，例如精度和召回率。
如果您正在处理疾病分类等问题，其中一类数据在您的数据集中表示不足，您可能会遇到模型仅预测多数类的问题。
高验证准确性并不是表现良好的模型的唯一指标。
如果你想了解更多关于其他分类指标的信息，你可以观看这个视频。要了解更多关于解决分类问题中不平衡数据集的问题，你可以跟随这篇教程。
本文到此为止！我希望你能从这篇教程中学到一些东西。
请务必看看我在整篇文章中链接的其他资源。
现在，您已经对机器学习建模的工作原理有了很高的理解，这些资源将帮助您对您实现的所有内容有一个很好的理解。
它们将有助于巩固您对不同数据预处理技术、不同算法如何工作以及可用于评估模型性能的不同指标的理解。
使用 R 中的正则表达式匹配任何模式的初学者指南
瑞安·弗兰科在 Unsplash 上拍摄的照片
这比你想象的要容易
正则表达式只不过是与一段文本或文本文件中的模式相匹配的字符序列。在许多编程语言中，它被用于文本挖掘。在所有语言中，正则表达式的字符都非常相似。但是提取、定位、检测和替换的功能在不同的语言中可能是不同的。
在本文中，我将使用 r。但是，即使您希望使用其他语言，也可以从本文中学习如何使用正则表达式。当你不知道的时候，它可能看起来太复杂了。但是正如我在上面提到的，这比你想象的要容易。我会尽我所能解释它。如果你有不明白的地方，欢迎在评论区问我问题。
在这里我们将边做边学。我将从非常基本的想法开始，慢慢走向更复杂的模式。
在本文的所有练习中，我都使用了 RStudio。
这是一组包含不同模式的 7 个字符串。我们将用它来学习所有的基础知识。
ch = c('Nancy Smith',
'is there any solution?',
".[{(^$|?*+",
"coreyms.com",
"321-555-4321",
"123.555.1234",
"123*555*1234"
)
从这些文本中提取所有的点或句点:
r 有一个名为‘str _ extract _ all’的函数，它将从这些字符串中提取所有的点。这个函数有两个参数。首先是感兴趣的文本，其次是要提取的元素。
str_extract_all(ch, "\\.")
输出:
[[1]]
character(0)[[2]]
character(0)[[3]]
[1] "."[[4]]
[1] "."[[5]]
character(0)[[6]]
[1] "." "."[[7]]
character(0)
仔细查看输出。第三根弦有一个点。第四根弦有一个点，第六根弦有两个点。
R ' str _ extract '中还有一个函数，只从每个字符串中提取第一个点。
你自己试试。我将在本文的所有演示中使用 str_extract_all 来查找所有内容。
在进行更多的训练之前，最好先看看正则表达式的模式列表:
- 。=匹配任何字符
2.\d =数字(0–9)
3.\D =不是数字(0–9)
4.\w =单词字符(a-z，A-Z，0–9，_)
5.\W =不是单词字符
6.\s =空白(空格、制表符、换行符)
7.\S =非空白(空格、制表符、换行符)
8.\b =单词边界
9.\B =不是单词边界
10.^ =字符串的开头
11.$ =字符串的结尾
12.[] =匹配字符或括号
13.[^ ] =匹配不在括号中的字符
14。| =非此即彼
15.()=组
16.*= 0 或以上
17.+ = 1 或更大
18.？=是或否
19.{x} =确切的数字
20.{x，y} =数字范围(最大值，最小值)
我们以后工作的时候会一直参考这个表情列表。
我们将首先单独研究所有这些问题，然后分组研究。
从基础开始
按照上面的列表，' \d '捕捉数字。
从‘ch’中提取所有数字:
str_extract_all(ch, "\\d")
输出:
[[1]]
character(0)[[2]]
character(0)[[3]]
character(0)[[4]]
character(0)[[5]]
[1] "3" "2" "1" "5" "5" "5" "4" "3" "2" "1"[[6]]
[1] "1" "2" "3" "5" "5" "5" "1" "2" "3" "4"[[7]]
[1] "1" "2" "3" "5" "5" "5" "1" "2" "3" "4"
前四个字符串没有任何数字。最后三个字符串是电话号码。上面的表达式可以捕捉最后三个字符串中的所有数字。
大写的“D”将捕捉除数字以外的所有内容。
str_extract_all(ch, "\\D")
输出:
[[1]]
[1] "a" "b" "c" "d" "e" "f" "g" "h" "i"
[[2]]
[1] "A" "B" "C" "D" "E" "F" "G" "H" "I"[[3]]
[1] "T" "h" "i" "s" " " "i" "s" " " "m" "e"[[4]]
[1] "." "[" "{" "(" "^" "$" "|" "?" "*" "+"[[5]]
[1] "c" "o" "r" "e" "y" "m" "s" "." "c" "o" "m"[[6]]
[1] "-" "-"[[7]]
[1] "." "."[[8]]
[1] "*" "*"
看，它提取了字母、点和其他特殊字符，但没有提取任何数字。
“w”匹配包含 a-z、A-Z、0–9 和“_”的单词字符。让我们检查一下。
str_extract_all(ch, "\\w")
输出:
[[1]]
[1] "a" "b" "c" "d" "e" "f" "g" "h" "i"[[2]]
[1] "A" "B" "C" "D" "E" "F" "G" "H" "I"[[3]]
[1] "T" "h" "i" "s" "i" "s" "m" "e"[[4]]
character(0)[[5]]
[1] "c" "o" "r" "e" "y" "m" "s" "c" "o" "m"[[6]]
[1] "3" "2" "1" "5" "5" "5" "4" "3" "2" "1"[[7]]
[1] "1" "2" "3" "5" "5" "5" "1" "2" "3" "4"[[8]]
[1] "1" "2" "3" "5" "5" "5" "1" "2" "3" "4"
除了点和特殊字符，它什么都有。
但是，“W”会提取除单词字符以外的所有内容。
str_extract_all(ch, "\\W")
输出:
[[1]]
character(0)[[2]]
character(0)[[3]]
[1] " " " "[[4]]
[1] "." "[" "{" "(" "^" "$" "|" "?" "*" "+"[[5]]
[1] "."[[6]]
[1] "-" "-"
我现在要展示“B”和“B”。“b”表示边界这个词。这里有一个例子:
st = "This is Bliss"
str_extract_all(st, "\\bis")
输出:
[[1]]
[1] "is"
字符串中只有一个“is”。所以我们可以在这里抓到它。让我们看看 B 的用法
st = "This is Bliss"
str_extract_all(st, "\\Bis")
输出:
[[1]]
[1] "is" "is"
在字符串' st '中，还有两个' is '不在边界内。那是在‘这个’和‘极乐’两个字里。当你用大写的 B 时，你就抓住了它们。
上面表达式列表中的数字 10 和 11 是'^'和' $ '，分别表示字符串的开始和结束。
这里有一个例子:
sts = c("This is me",
"That my house",
"Hello, world!")
找出所有结束一个句子的感叹号。
str_extract_all(sts, "!$")
输出:
[[1]]
character(0)[[2]]
character(0)[[3]]
[1] "!"
我们只有一个以感叹号结尾的句子。如果 R 用户想找到以感叹号结尾的句子:
sts[str_detect(sts, "!$")]
输出:
[1] "Hello, world!"
找出以“This”开头的句子。
sts[str_detect(sts, "^This")]
输出:
[1] "This is me"
那也只有一个。
让我们找出以“T”开头的句子。
sts[str_detect(sts, "^T")]
输出:
[1] "This is me" "That my house"
'[]'匹配其中的字符或范围。
对于本演示，让我们回到“ch”。提取 2-4 之间的所有内容。
str_extract_all(ch, "[2-4]")
输出:
[[1]]
character(0)[[2]]
character(0)[[3]]
character(0)[[4]]
character(0)[[5]]
[1] "3" "2" "4" "3" "2"[[6]]
[1] "2" "3" "2" "3" "4"[[7]]
[1] "2" "3" "2" "3" "4"
让我们继续一些更大的实验
仅从“ch”中提取电话号码。在您看到输出后，我将解释该模式:
str_extract(ch, "\\d\\d\\d.\\d\\d\\d.\\d\\d\\d\\d")
输出:
[1] NA NA NA
[4] NA "321-555-4321" "123.555.1234"
[7] "123*555*1234"
在上面的正则表达式中，每个“\d”表示一个数字，而“.”可以匹配两者之间的任何内容(请看开头的表达式列表中的数字 1)。所以我们得到了数字，然后中间有一个特殊字符，再有三个数字，再有特殊字符，再有四个数字。所以符合这些标准的都被提取出来了。
上述电话号码的正则表达式也可以写成如下形式。
str_extract(ch, "\\d{3}.\\d{3}.\\d{4}")
输出:
[1] NA NA NA
[4] NA "321-555-4321" "123.555.1234"
[7] "123*555*1234"
看看表达式列表的第 19 项。{x}表示确切的数字。这里我们使用了{3}，表示正好 3 次。\d{3} '表示三位数。
但是数字之间的“”不是常规的电话号码格式。通常是“-”或“.”可以在电话号码中用作分隔符。对吗？让我们匹配一下，排除带“”的电话号码。因为这可能看起来像一个 10 位数的电话号码，但它可能不是一个电话号码。我们想坚持常规的电话号码格式。
str_extract(ch, "\\d{3}[-.]\\d{3}[-.]\\d{4}")
输出:
[1] NA NA NA
[4] NA "321-555-4321" "123.555.1234"
[7] NA
听着，这只符合通常的电话号码格式。在这个表达式中，在三位数之后我们明确提到了'[-。]'，这意味着它只要求匹配'-'或一个点('.').
以下是电话号码列表:
ph = c("543-325-1278",
"900-123-7865",
"421.235.9845",
"453*2389*4567",
"800-565-1112",
"361 234 4356"
)
如果我们在这些电话号码上使用上面的表达式，会发生以下情况:
str_extract(ph, "\\d{3}[-.]\\d{3}[-.]\\d{4}")
输出:
[1] "543-325-1278" "900-123-7865" "421.235.9845"
[4] NA "800-565-1112" NA
看啊！这种格式不包括“361 234 4356”。有时我们在中间不用任何分隔符，只用一个空格，对吗？此外，美国电话号码的第一个数字不是 0 或 1。这是一个介于 2 到 9 之间的数字。所有其他数字可以是 0 到 9 之间的任何数字。让我们来关注一下这个模式。
p = "([2-9][0-9]{2})([- .]?)([0-9]{3})([- .])?([0-9]{4})"
str_extract(ph, p)
我在这里单独保存了图案。
在正则表达式中，“()”用于表示一个组。看看表达式列表中的第 15 个。
下面是上面表达式的分解。
第一组是“([2–9][0–9]{ 2 })”:
[2–9]'代表 2 到 9 之间的一个数字
“[0–9]{ 2 }”表示从 0 到 9 的两个数字
第二组是“([-。]?)":
'[-.]'表示它可以是'-'或'.'
使用“？”在那之后的意思是“-”和。“是可选的。所以，如果是空白的也没关系。
我估计其他组现在也清楚了。
下面是上面表达式的输出:
[1] "543-325-1278" "900-123-7865" "421.235.9845"
[4] NA "800-565-1112" "361 234 4356"
它查找带有'-'、'.'的电话号码，也可以用空格作为分隔符。
如果我们需要找到 800 和 900 开头的电话号码呢？
p = "[89]00[-.]\\d{3}[-.]\\d{4}"
str_extract_all(ph, p)
输出:
[[1]]
character(0)[[2]]
[1] "900-123-7865"[[3]]
character(0)[[4]]
character(0)[[5]]
[1] "800-565-1112"[[6]]
character(0)
先来理解一下上面的正则表达式:“[89]00[-]。]\d{3}[-。]\d{4} "。
第一个字符应该是 8 或 9。这可以通过[89]来实现。
接下来的两个元素将为零。我们明确提到过。
然后是“-”或“.”可以通过[-]获得。].
接下来的三位数= \d{3}
又是“-”或“.”= [-.]
末尾还有四位数字= \d{4}
提取不同格式的邮件地址
电子邮件地址比电话号码稍微复杂一些。因为电子邮件地址可能包含大写字母、小写字母、数字、特殊字符等等。以下是一组电子邮件地址:
email = c("[RashNErel@gmail.com](mailto:RashNErel@gmail.com)",
"[rash.nerel@regen04.net](mailto:rash.nerel@regen04.net)",
"[rash_48@uni.edu](mailto:rash_48@uni.edu)",
"[rash_48_nerel@STB.org](mailto:rash_48_nerel@STB.org)")
我们将开发一个正则表达式来提取所有这些电子邮件地址:
首先处理“@”符号之前的部分。此部分可能包含可使用[a-z]检测的小写字母、可使用[A-Z]检测的大写字母、可使用[0–9]查找的数字以及特殊字符，如“.”、和“_”。它们都可以这样包装:
"[阿-扎-Z0-9-。]+"
“+”号表示这些字符中的一个或多个(请看表达式列表中的第 17 个)。因为我们不知道有多少不同的字母、数字或数字。所以这一次我们不能像对电话号码那样使用{x}。
现在处理“@”和“.”之间的部分。该部分可能由大写字母、小写字母和数字组成，可以检测为:
"[a-zA _ Z0–9]+"
最后是“.”后面的部分。。这里我们有四个“com”，“net”，“edu”，“org”。这四个可以用一组来捕捉:
“(com | edu |网|org”)
这里“|”符号用于表示-或。请看开头的表达式列表中的第 14 个。
下面是完整的表达式:
p = "[a-zA-Z0-9-.]+@[a-zA_Z0-9]+\\.(com|edu|net|org)"
str_extract_all(email, p)
输出:
[[1]]
[1] "[RashNErel@gmail.com](mailto:RashNErel@gmail.com)"[[2]]
[1] "[rash.nerel@regen.net](mailto:rash.nerel@regen.net)"[[3]]
[1] "[48@uni.edu](mailto:48@uni.edu)"[[4]]
[1] "[nerel@stb.com](mailto:nerel@stb.com)"
如果你不提及圆点后的部分，它也会起作用。因为我们在第二部分后添加了一个“+”号，这意味着它将在其后接受任意数量的字符。
但是，如果你需要某些特定的域类型，比如“com”或“net ”,你必须像我们在前面的表达式中所做的那样明确地提到它们。
p = "[a-zA-Z0-9-.]+@[a-zA_Z0-9-.]+"
str_extract_all(email, p)
输出:
[[1]]
[1] "[RashNErel@gmail.com](mailto:RashNErel@gmail.com)"[[2]]
[1] "[rash.nerel@regen.net](mailto:rash.nerel@regen.net)"[[3]]
[1] "[48@uni.edu](mailto:48@uni.edu)"[[4]]
[1] "[nerel@stb.com](mailto:nerel@stb.com)"
另一种常见的复杂类型是网址
以下是 URL 列表:
urls = c("[https://regenerativetoday.com](https://regenerativetoday.com/)",
"[http://setf.ml](http://setf.ml/)",
"[https://www.yahoo.com](https://www.yahoo.com/)",
"[http://studio_base.net](http://studio_base.net/)",
)
它可能以“http”或“https”开头。要检测该表达式是否可以使用:
https，”
这意味着“http”将保持不变。然后有一个“？”在“s”后面签名。所以，“s”是可选的。它可能在那里，也可能不在那里。
另一个可选部分在“😕/”术语之后:“www。”我们可以用以下方式定义它:
”(www\。)?"
正如我们之前所做的，'()'用于对一些表达式进行分组。这里我们将“www”和“.”分组。括号后的那个“？”意味着括号内的这一项是可选的。他们可能在那里，也可能不在那里。
然后是域名。在这组电子邮件地址中，我们只有小写字母和“_”。所以，[a-z-]会起作用。但是在一般的域名中，也可能包含大写字母和数字。因此，我们将使用:
" \w+"
请看表达式列表中的数字 4。\w '表示可以包括小写字母、大写字母和数字的单词字符。“+”号表示可能有一个或多个这样的字符。
在域之后，多了一个点，然后是更多的字符。我们将让他们使用:
"\.\w+"
请记住，如果您只使用点(。)来匹配一个点是行不通的。因为只有一个点匹配任何字符。如果您只需要匹配一个文字点(。)，你需要把它写成' \ . '
这里我们使用了一个点，用“\”表示。，然后是单词字符“\w”和一个“+”号，表示还有更多字符。
我们把它放在一起:
p = "https?://(www\\.)?\\w+\\.\\w+"
str_extract_all(urls, p)
输出:
[[1]]
[1] "[https://regenerativetoday.com](https://regenerativetoday.com/)"[[2]]
[1] "[http://setf.ml](http://setf.ml/)"[[3]]
[1] "[https://www.yahoo.com](https://www.yahoo.com/)"[[4]]
[1] "[http://studio_base.com](http://studio_base.com/)"
你可能只想得到。com 或。net”域。可以明确提到的。
p = "https?://(www\\.)?(\\w+)(\\.)+(com|net)"
str_extract_all(urls, p)
输出:
[[1]]
[1] "[https://regenerativetoday.com](https://regenerativetoday.com/)"[[2]]
character(0)[[3]]
[1] "[https://www.yahoo.com](https://www.yahoo.com/)"[[4]]
[1] "[http://studio_base.com](http://studio_base.com/)"
你看，它只会变得。com '或'。net”域并排除。我们拥有的 ml 域名。
最后研究出一组名字
这也有点棘手。这里有一组名字:
name = c("Mr. Jon",
"Mrs. Jon",
"Mr Ron",
"Ms. Reene",
"Ms Julie")
看，它可能以先生、女士或夫人开头，有时在先生后面有一个点，有时没有。让我们首先在这一部分上工作。在所有这些单词中，M 都很常见。保持完整，然后像这样用剩下的部分组成一个组:
" M(r|s|rs)"
在 M 后面可能是 r 或 s 或 rs。
然后是一个可选的点，可以通过使用:
“\.?”
后面有一个空格，可以用以下命令来检测:
" \s "
在空间名称以大写字母开始之后，可以使用:
[A-Z]"
在大写字母之后，还有一些小写字母，我们不知道具体有多少。所以，我们会用这个:
" \w* "
请看表达式列表中的第 16 个数字。* '表示 0 或更多。所以，我们说可能有 0 个或更多的单词字符。
将所有这些放在一起:
p = "M(r|s|rs)\\.?[A-Z\\s]\\w*"
str_extract_all(name, p)
输出:
[[1]]
[1] "Mr. Jon"[[2]]
[1] "Mrs. Jon"[[3]]
[1] "Mr Ron"[[4]]
[1] "Ms. Reene"[[5]]
[1] "Ms Julie"
恭喜你！您处理了一些复杂而又酷的模式，这些模式应该给了您足够的知识来使用正则表达式匹配几乎任何模式。
结论
这还不是全部。正则表达式中还有很多。但是，如果你是一个初学者，你应该为自己的进步感到骄傲。你现在应该可以匹配几乎任何模式。我将在以后的某个时候制作另一个关于高级正则表达式的教程。但是你现在应该能够开始使用正则表达式来做一些很酷的事情。
欢迎在推特上关注我，喜欢我的 T2 脸书页面。
OCTIS 入门指南第 1 卷:优化和比较主题模型很简单
实践教程
拥有最高数量的集成的最先进的主题模型的 Python 包。
主题模型是一种有前途的生成统计方法，旨在提取文档集合中隐藏的主题。通常，主题模型有两个矩阵作为输出。
1.主题单词矩阵(词汇 x 数字 _ 主题)，表示单词 i 出现在主题 k. 中的概率
2.主题-文档-矩阵(数量 _ 主题 x 数量 _ 文档)。
然后，来自该矩阵的具有最高概率的前 n 个单词被用于表示主题。
最流行的主题建模方法是潜在的 Dirichlet 分配，许多文章都是关于它的工作和实现的。然而，只关注 LDA 是有限制的，并且对于给定的语料库可能是次优的。对于给定的语料库，其他主题模型可能更好。
最近发布了新的 Python 包，OCTIS(优化和比较主题模型很简单！).根据它的名字，OCTIS 允许在主题模型之间进行简单的比较，这不会让你感到惊讶。该软件包包含多个主题模型、数据集、评估指标和优化选项。
在这篇博客中，我演示了如何开始使用这个包。在以后的博客中，我将更详细地讨论主题模型优化和比较。
首先安装软件包:
pip install octis
我们需要一个数据集。
from octis.dataset.dataset import Dataset
OCTIS 有四个内置数据集:
让我们从最小的开始:
dataset = Dataset()dataset.fetch_dataset('BBC_news')
要选择其他数据集，请从表中选择一个名称(注意代码中“BBC_news”的拼写不同于表中的拼写。其他名称相同)。
现在，让我们看看数据集是什么样子的:
len(dataset._Dataset__corpus)
>>> 2225len(dataset._Dataset__vocabulary)
>>> 2949print(dataset._Dataset__corpus[0:5])
>>> [[‘broadband’, ‘ahead’, ‘join’, ‘internet’, ‘fast’, ‘accord’, ‘official’, ‘figure’, ‘number’, ‘business’, ‘connect’, ‘jump’, ‘report’, ‘broadband’, ‘connection’, ‘end’, ‘compare’, ‘nation’, ‘rank’, ‘world’, ‘telecom’, ‘body’, ‘election’, ‘campaign’, ‘ensure’, ‘affordable’, ‘high’, ‘speed’, ‘net’, ‘access’, ‘american’, ‘accord’, ‘report’, ‘broadband’, ‘increasingly’, ‘popular’, ‘research’, ‘shopping’, ‘download’, ‘music’, ‘watch’, ‘video’, ‘total’, ‘number’, ‘business’, ‘broadband’, ‘rise’, ‘end’, ‘compare’, ‘hook’, ‘broadband’, ‘subscriber’, ‘line’, ‘technology’, ‘ordinary’, ‘phone’, ‘line’, ‘support’, ‘high’, ‘data’, ‘speed’, ‘cable’, ‘lead’, ‘account’, ‘line’, ‘broadband’, ‘phone’, ‘line’, ‘connection’, ‘accord’, ‘figure’],[‘plan’, ‘share’, ‘sale’, ‘owner’, ‘technology’, ‘dominate’, ‘index’, ‘plan’, ‘sell’, ‘share’, ‘public’, ‘list’, ‘market’, ‘operate’, ‘accord’, ‘document’, ‘file’, ‘stock’, ‘market’, ‘plan’, ‘raise’, ‘sale’, ‘observer’, ‘step’, ‘close’, ‘full’, ‘public’, ‘icon’, ‘technology’, ‘boom’, ‘recently’, ‘pour’, ‘cold’, ‘water’, ‘suggestion’, ‘company’, ‘sell’, ‘share’, ‘private’, ‘technically’, ‘public’, ‘stock’, ‘start’, ‘trade’, ‘list’, ‘equity’, ‘trade’, ‘money’, ‘sale’, ‘investor’, ‘buy’, ‘share’, ‘private’, ‘filing’, ‘document’, ‘share’, ‘technology’, ‘firm’, ‘company’, ‘high’, ‘growth’, ‘potential’, ‘symbol’, ‘internet’, ‘telecom’, ‘boom’, ‘bubble’, ‘burst’, ‘recovery’, ‘fortune’, ‘tech’, ‘giant’, ‘dot’, ‘revive’, ‘fortune’],[‘mobile’, ‘rack’, ‘mobile’, ‘phone’, ‘celebrate’, ‘anniversary’, ‘weekend’, ‘mobile’, ‘phone’, ‘call’, ‘vodafone’, ‘network’, ‘veteran’, ‘day’, ‘mobile’, ‘phone’, ‘integral’, ‘part’, ‘modern’, ‘life’, ‘briton’, ‘handset’, ‘mobile’, ‘popular’, ‘handset’, ‘phone’, ‘rarely’, ‘call’, ‘portable’, ‘phone’, ‘commercial’, ‘mobile’, ‘service’, ‘launch’, ‘rest’, ‘world’, ‘set’, ‘network’, ‘call’, ‘walk’, ‘call’, ‘office’, ‘house’, ‘day’, ‘vodafone’, ‘firm’, ‘mobile’, ‘network’, ‘launch’, ‘service’, ‘spokesman’, ‘phone’, ‘launch’, ‘size’, ‘cost’, ‘battery’, ‘life’, ‘minute’, ‘hugely’, ‘popular’, ‘mid’, ‘status’, ‘symbol’, ‘young’, ‘business’, ‘fact’, ‘phone’, ‘radio’, ‘signal’, ‘communicate’, ‘easy’, ‘rack’, ‘customer’, ‘month’, ‘easy’, ‘forget’, ‘put’, ‘bid’, ‘document’, ‘forecast’, ‘total’, ‘market’, ‘forecast’, ‘vodafone’, ‘customer’, ‘vodafone’, ‘mobile’, ‘phone’, ‘operator’, ‘launch’, ‘launch’, ‘newcomer’, ‘operate’, ‘mobile’, ‘network’, ‘operator’, ‘technology’, ‘spectrum’, ‘phone’, ‘retire’, ‘call’, ‘global’, ‘system’, ‘mobile’, ‘widely’, ‘phone’, ‘technology’, ‘planet’, ‘call’, ‘digital’, ‘technology’, ‘introduce’, ‘thing’, ‘text’, ‘mobile’, ‘popular’],[‘launch’, ‘reconstruction’, ‘drive’, ‘appeal’, ‘peace’, ‘national’, ‘unity’, ‘important’, ‘find’, ‘solution’, ‘internal’, ‘conflict’, ‘damage’, ‘tsunami’, ‘cut’, ‘percentage’, ‘point’, ‘economic’, ‘growth’, ‘estimate’, ‘wave’, ‘leave’, ‘physical’, ‘damage’, ‘equal’, ‘economy’, ‘separately’, ‘lose’, ‘call’, ‘action’, ‘create’, ‘job’, ‘attend’, ‘ceremony’, ‘southern’, ‘town’, ‘join’, ‘government’, ‘opposition’, ‘politician’, ‘lay’, ‘foundation’, ‘stone’, ‘housing’, ‘project’, ‘intend’, ‘provide’, ‘home’, ‘tsunami’, ‘call’, ‘tragedy’, ‘start’, ‘beginning’, ‘rebuild’, ‘nation’, ‘country’, ‘natural’, ‘resource’, ‘fully’, ‘fight’, ‘add’, ‘due’, ‘arrive’, ‘revive’, ‘peace’, ‘talk’, ‘decade’, ‘long’, ‘conflict’, ‘government’, ‘force’, ‘tiger’, ‘separate’, ‘state’, ‘country’, ‘reconstruction’, ‘effort’, ‘hamper’, ‘tension’, ‘side’, ‘authority’, ‘initial’, ‘estimate’, ‘put’, ‘physical’, ‘damage’, ‘add’, ‘implication’, ‘economy’, ‘wide’, ‘broad’, ‘impact’, ‘substantial’, ‘detail’, ‘difficult’, ‘assess’, ‘early’, ‘stage’, ‘growth’, ‘inflation’, ‘balance’, ‘payment’, ‘foreign’, ‘exchange’, ‘reserve’, ‘expect’, ‘show’, ‘effect’, ‘lose’, ‘business’, ‘reconstruction’, ‘cost’, ‘industry’, ‘agricultural’, ‘production’, ‘affect’, ‘tourism’, ‘suffer’, ‘short’, ‘term’, ‘report’, ‘estimate’, ‘lose’, ‘job’, ‘industry’, ‘earning’, ‘tourism’, ‘expect’, ‘low’, ‘economic’, ‘growth’, ‘expect’, ‘previously’, ‘forecast’, ‘inflation’, ‘climb’, ‘compare’, ‘previous’, ‘estimate’, ‘major’, ‘export’, ‘suffer’, ‘expect’, ‘reconstruction’, ‘effort’, ‘require’, ‘high’, ‘import’, ‘damage’, ‘balance’, ‘payment’, ‘foreign’, ‘exchange’, ‘reserve’, ‘hard’, ‘press’, ‘international’, ‘reserve’, ‘pre’, ‘tsunami’, ‘level’, ‘total’, ‘month’, ‘worth’, ‘import’, ‘week’, ‘approve’, ‘request’, ‘freeze’, ‘loan’, ‘repayment’],[‘buy’, ‘giant’, ‘profit’, ‘soar’, ‘acquisition’, ‘big’, ‘firm’, ‘tax’, ‘profit’, ‘rise’, ‘expect’, ‘solid’, ‘growth’, ‘performance’, ‘sale’, ‘firm’, ‘world’, ‘big’, ‘volume’, ‘buy’, ‘acquisition’, ‘sale’, ‘volume’, ‘grow’, ‘month’, ‘sale’, ‘account’, ‘increase’, ‘sell’, ‘volume’, ‘big’, ‘term’, ‘sale’, ‘continue’, ‘demand’, ‘product’, ‘south’, ‘american’, ‘market’, ‘brazilian’, ‘arm’, ‘popular’, ‘expect’, ‘boost’, ‘turnover’, ‘business’, ‘analyst’, ‘strong’, ‘performance’, ‘boost’, ‘share’, ‘market’, ‘end’, ‘report’, ‘contrast’, ‘volume’, ‘sale’, ‘fall’, ‘central’, ‘european’, ‘sale’, ‘rise’, ‘net’, ‘profit’]]
那很好；每个文档都是预处理过的标记列表，所以这里不需要进行任何预处理。
OCTIS 有八个内置主题模型:
(如果您实现了其中一个模型，请确保引用正确的论文)
现在，让我们用这些数据训练一个 NeuralLDA 模型:
from octis.models.NeuralLDA import NeuralLDA
通过用上表中的名称替换“NeuralLDA”，可以类似地导入其他主题模型(注意，“ProdLda”需要是“ProdLDA”)。
初始化模型:
model = NeuralLDA(num_topics=20)
所有不同的主题模型都包含“num_topics”。其他参数因型号而异，可以在实现页面上找到。但是，检查源代码可以更快地找到参数:
import inspectprint(inspect.getsource(NeuralLDA))>>> class NeuralLDA(AVITM):def __init__(self, num_topics=10, activation=’softplus’, dropout=0.2, learn_priors=True, batch_size=64, lr=2e-3,momentum=0.99, solver=’adam’, num_epochs=100, reduce_on_plateau=False, prior_mean=0.0,prior_variance=None, num_layers=2, num_neurons=100, num_samples=10, use_partitions=True):…
构造函数中的参数可以手动设置。在这种情况下，它们是:
num_topicsactivationdropoutlearn_priorsbatch_sizelrmomentumsolvernum_epochsreduce_on_plateauprior_meanprior_variancenum_layersnum_neuronsnum_samplesuse_partition
现在，我们将简单地使用默认设置，并将num_topics = 20:
model = NeuralLDA(num_topics=20)trained_model = model.train_model(dataset)#Now, you should see something like:Epoch: [1/100] Samples: [1557/155700] Train Loss: 987.1886277195729 Time: 0:00:00.352704Epoch: [1/100] Samples: [334/33400] Validation Loss: 982.9130479275823 Time: 0:00:00.020085Epoch: [2/100] Samples: [3114/155700] Train Loss: 990.8275228805395 Time: 0:00:00.362417Epoch: [2/100] Samples: [334/33400] Validation Loss: 982.0897677301647 Time: 0:00:00.010114Epoch: [3/100] Samples: [4671/155700] Train Loss: 981.4996826328677 Time: 0:00:00.362483Epoch: [3/100] Samples: [334/33400] Validation Loss: 965.4536162050898 Time: 0:00:00.010038
trained_model 是一个字典，具有以下键:
print(trained_model.keys())>>> dict_keys([‘topics’, ‘topic-document-matrix’, ‘topic-word-matrix’, ‘test-topic-document-matrix’])
这些键如下:
- 主题:word 主题列表
- topic-word-matrix :每个主题的词汇的单词分布(维度:|num topics| x |vocabulary|)
- 主题-文档-矩阵:训练集每个文档的主题分布(维度:|主题数| x |训练文档|)
- test-document-topic-matrix:测试集每个文档的主题分布(维度:|num topics| x |test documents|)
第一个关键字topics由来自主题单词矩阵的每个主题具有最高概率的 n 个单词的列表组成。
让我们看看这些是什么:
for topic in trained_model[‘topics’]:
print(“ “.join(topic))>>> claim chief meet budget official talk cut raise future economicwin side match final chance team season half great goalcompany market sale month share expect rise fall growth reportcharge competition link victim ago injury anti tragedy decision missgovernment plan party add election public give claim week torygame show give big play add back week put findcompany find user firm technology mobile service phone accord informationcase evidence order trial concern court common law clear powerenjoy tragedy rest carry navigate motion admit date opener technologicalchoose tragedy due motion navigate involve manage suffer stiff technologicalfilm good top award star director movie chance performance careerrival reveal drug short range break challenge battle focus fourthtragedy position seller navigate squeeze motion rare flanker overwhelming technologicalinclude follow number hit man release hold place record bandtragedy navigate seller earn join escape squeeze opener adoption technological
通常，连贯性被用来评估主题的质量。让我们也检查一下这个模型的一致性:
from octis.evaluation_metrics.coherence_metrics import Coherence
在不同的一致性度量中，c_v与人工翻译的相关性最高。
cv = Coherence(texts=dataset.get_corpus(),topk=10, measure=’c_v’)
print(‘Coherence: ‘ + str(cv.score(trained_model)))
>>> Coherence: 0.4963712149432245
(与典型的主题建模符号相反，‘topk’表示主题中包含的单词数，而不是主题数。由于我们的主题模型每个主题有十个单词，‘topk’不能超过 10 个)。
此外，OCTIS 还可以选择计算所谓的“多样性得分”，即主题中独特词的百分比。这个分数是制作主题质量的另一个指标。如果没有很多独特的话，那么很多话题都是大同小异，意义不是很大。
from octis.evaluation_metrics.diversity_metrics import TopicDiversitydiversity = TopicDiversity(topk=10)
print('Diversity score: '+str(diversity.score(trained_model)))
>>> Diversity score: 0.8533333333333334
连贯性和多样性主要用于比较不同主题模型的主题。在下一篇博客中，我将展示如何优化主题模型。
如果你喜欢这项工作，你可能会对主题建模感兴趣。在这种情况下，您可能也会对以下内容感兴趣。
我们创建了一个新的话题建模算法，叫做 FLSA-W (官方页面是这里，但是你可以看到论文这里)。
在几个公开数据集上，FLSA-W 算法的性能优于其他一流算法(如 LDA、ProdLDA、NMF、CTM 等)。 该作品 已提交，但尚未通过同行评审。
如果想用 FLSA-W，可以下载 Gensim 中的FuzzyTM 包 或者 flsamodel。如需引用，请用本文。
OCTIS 入门指南第 2 卷:优化主题模型
乔尔·菲利普在 Unsplash 上的照片
在之前的一篇帖子中，我介绍了 Python 包 OCTIS(优化和比较主题模型很简单)；我演示了如何开始和它的特性。这个包允许简单的主题模型优化和比较(顾名思义)。这篇文章主要关注名字的第一个字母:Ooptimization。
在这篇文章的结尾，你将会:
- 对超参数优化有基本的了解。
- 知道优化主题模型时要考虑什么。
- 能够优化你自己的主题模型。
超参数优化
几乎所有的机器学习算法都有超参数。超参数表示学习过程的算法所使用的设置；基于这些设置，算法遵循学习程序来学习其参数。然而，确定每个超参数的最佳值并不简单，通常通过先进的试错法来完成，也称为超参数优化。使用这些超参数调整方法中的任何一种，算法都是基于一组超参数来训练的。该算法的结果通过性能指标或误差测量来评估。然后，(稍微)调整超参数，并基于新的设置训练和评估模型。最基本的方法是网格搜索，其中算法在一组预定义设置的所有组合上进行训练。网格搜索很容易编码，可以并行运行，不需要任何形式的调整。然而，在搜索空间中导航是低效的，因为它不使用在早期尝试中获得的信息。由于搜索可能不包括所有可能的设置，因此无法保证找到最佳值。
找到超参数的更有效的方法是通过基于模型的顺序优化(SMBO)。这里，性能指标/误差测量的替代模型可以适合先前的尝试并指示最佳点。
一种常见的 SMBO 方法是贝叶斯优化，它可以通过高斯过程回归来解释。使用高斯过程回归，附加信息(新的超参数设置信息)被添加到已经采样的点的先验中。贝叶斯优化仅对优化少数超参数有效。然而，随着搜索空间的增加，性能会下降。此外，贝叶斯优化不能并行化，因为新学习的信息被添加到先验中。高斯过程回归的更多细节可在这里找到，超参数优化方法的更详细回顾可在这里找到。
利用 OCTIS 优化主题模型
OCTIS 使用贝叶斯优化进行超参数优化。在我之前的帖子中，我在 BBC 数据集上训练了一个 NeuralLDA 模型，所以我在这里也将这样做。
假设你已经安装了 OCTIS，我们直接用 Python 开始吧。同样，我们需要导入数据集和 NeuralLDA 模型:
from octis.dataset.dataset import Dataset
from octis.models.NeuralLDA import NeuralLDA
此外，我们安装优化空间、一致性(我们将其用作评估每个设置的性能指标)和优化器本身:
from skopt.space.space import Real, Categorical, Integer
from octis.evaluation_metrics.coherence_metrics import Coherence
from octis.optimization.optimizer import Optimizer
让我们获取数据集并初始化模型，我们差不多准备好了:
dataset = Dataset()
dataset.fetch_dataset('BBC_news')model = NeuralLDA(num_topics=20)
在前一篇文章中，我们发现 NeuralLDA 具有以下(超级)参数:
num_topicsactivationdropoutlearn_priorsbatch_sizelrmomentumsolvernum_epochsreduce_on_plateauprior_meanprior_variancenum_layersnum_neuronsnum_samplesuse_partition
搜索空间
理论上，所有这些变量都可以优化。但由于贝叶斯优化在高维搜索空间中表现不佳，我们将搜索空间维度限制为三个变量:
search_space = {"num_layers": Integer(1,3),
"num_neurons": Categorical({100, 200, 300}),
"dropout": Real(0.0, 0.95)}
对于Categorical值，需要列出所有可能的值，而下限和上限只需要在Real和Integer空间中给出。注意，虽然num_neurons是整数，但我们在这里将其定义为分类值，因此只考虑这三个值，而不是 100 到 300 之间的任何整数值。
连贯性
此外，我们基于连贯分数来评估不同的超参数设置，连贯分数指示了主题中不同单词相互支持的程度。计算一致性分数有多种方法。OCTIS 的默认一致性度量是c_npmi。然而，我推荐使用c_v，因为它与人类的理解更相关[1]:
coherence = Coherence(texts=dataset.get_corpus(), measure = ‘c_v’)
优化
现在我们几乎准备好开始优化。首先，我们需要定义优化迭代的次数，这是时间和性能之间的权衡。通常，更多的迭代意味着更高的性能，但这是以更长的训练时间为代价的。此外，更多的超参数意味着更多的迭代轮次。经验法则是使用 15 倍的超参数作为迭代次数。我们有三个超参数，所以我们将使用 45 次迭代。
optimization_runs=45
此外，每次训练新设置时，神经网络都用随机权重初始化。为了获得每个设置的可靠结果，每个设置都应该运行几次。然后，我们将这些测量值的中间值作为每个设置的代表。再次，模型运行次数是时间和质量的权衡；总训练时间比只跑一次长model_run倍。我们将使用 5:
model_runs=5
现在我们准备开始优化和保存结果。让我们为优化计时，以了解培训需要多长时间。这可能便于将来参考。
optimizer=Optimizer()import timestart = time.time()
optimization_result = optimizer.optimize(
model, dataset, coherence, search_space, number_of_call=optimization_runs,
model_runs=model_runs, save_models=True,
extra_metrics=None, # to keep track of other metrics
save_path='results/test_neuralLDA//')
end = time.time()
duration = end - startoptimization_result.save_to_csv("results_neuralLDA.csv")print('Optimizing model took: ' + str(round(duration)) + ' seconds.')
当模型正在训练时，您应该会在控制台中看到类似下图的内容:
Epoch: [49/100] Samples: [76293/155700] Train Loss: 922.4048726517341 Time: 0:00:00.465756
Epoch: [49/100] Samples: [334/33400] Validation Loss: 920.509180857036 Time: 0:00:00.027928
Epoch: [50/100] Samples: [77850/155700] Train Loss: 922.2904436115125 Time: 0:00:00.490685
Epoch: [50/100] Samples: [334/33400] Validation Loss: 920.9605340101048 Time: 0:00:00.027925
Epoch: [51/100] Samples: [79407/155700] Train Loss: 927.4208815028902 Time: 0:00:00.435834
Epoch: [51/100] Samples: [334/33400] Validation Loss: 920.7156858158683 Time: 0:00:00.026928
Early stopping
Optimizing model took: 6922 seconds.
所以，用了不到两个小时。不算太坏。
分析
现在，我们准备分析结果。是一本信息量很大的词典。
import json
results = json.load(open(“results/test_neuralLDA/result.json”,’r’))results.keys()>>> dict_keys(['dataset_name', 'dataset_path', 'is_cached', 'kernel', 'acq_func', 'surrogate_model', 'optimization_type', 'model_runs', 'save_models', 'save_step', 'save_name', 'save_path', 'early_stop', 'early_step', 'plot_model', 'plot_best_seen', 'plot_name', 'log_scale_plot', 'search_space', 'model_name', 'model_attributes', 'use_partitioning', 'metric_name', 'extra_metric_names', 'metric_attributes', 'extra_metric_attributes', 'current_call', 'number_of_call', 'random_state', 'x0', 'y0', 'n_random_starts', 'initial_point_generator', 'topk', 'time_eval', 'dict_model_runs', 'f_val', 'x_iters'])
而不是像以前那样测量时间。通过使用'time_eval'，我们可以看到每个模型的时间(/总时间):
results[‘time_eval’]>>> [184.53835153579712,
148.67225646972656,
109.24449896812439,
256.08221530914307,
154.24360704421997,
109.99915742874146,
160.35804772377014,
151.49168038368225,
155.40837001800537,
187.06181716918945,
130.2092640399933,
147.94106578826904,
123.84417510032654,
144.77754926681519,
161.64789295196533,
155.76212072372437,
135.94082117080688,
135.95739817619324,
173.89717316627502,
157.23684573173523,
163.68361639976501,
162.50231456756592,
149.47536158561707,
128.70402908325195,
160.75109601020813,
175.52507424354553,
172.95005679130554,
153.52869629859924,
186.61110424995422,
157.76874375343323,
191.34919786453247,
140.3497931957245,
132.05838179588318,
151.3189136981964,
153.88639116287231,
150.12475419044495,
178.27711153030396,
140.40700840950012,
94.96378469467163,
174.16378569602966,
92.2694320678711,
151.19830918312073,
152.21132159233093,
176.6853895187378,
147.0237419605255]sum(results[‘time_eval’])>>> 6922.101717710495
'f_val'显示不同运行中每个训练设置的中值。
results[“f_val”]>>> [0.4534176015984939,
0.4955475245370141,
0.38868674378398477,
0.4024525856722283,
0.47846034921413033,
0.3844368770533101,
0.4581705543253348,
0.4126574046864957,
0.4434880465386791,
0.49187868514620553,
0.5102920794834441,
0.48808652324541707,
0.4935514490937605,
0.4858721622773336,
0.4952236036028558,
0.465241037841993,
0.4881279220028529,
0.5023211922031112,
0.4990924448499987,
0.5024987857267208,
0.4770480035332,
0.5067195917253968,
0.4898287484351199,
0.4550063558556884,
0.4748375121047843,
0.497097248313755,
0.5034682220702588,
0.48220918244287975,
0.486563299332411,
0.4845033510847734,
0.4564350945897047,
0.4893138798649524,
0.4832975678079854,
0.4791275238679498,
0.4723902248816144,
0.5060161207074427,
0.49878190002894496,
0.4760453248044104,
0.47155389774180045,
0.5026397878110507,
0.40795520033104554,
0.5018909026526471,
0.5056155984233146,
0.4999288519956374,
0.49207181719944526]
这不是很直观，所以让我们画出来:
import matplotlib.pyplot as pltplt.xlabel(‘Iteration’)
plt.ylabel(‘Coherence score (c_v)’)
plt.title(‘Median coherence score per iteration’)
plt.plot(results[“f_val”])
plt.show()
从这个图中，我们可以看到模型并没有从高迭代次数中受益。最大中值得分出现在第 11 次迭代中，并且具有 0.51 的中值一致性得分:
results[ ‘f_val’].index(max(results[ ‘f_val’]))
>>> 10results["f_val"][10]
>>> 0.5102920794834441
现在，为了找到在第 11 次迭代中使用的设置，我们使用'x_iters’。这是一个包含已优化参数的字典:
results[‘x_iters’].keys()>>> dict_keys(['dropout', 'num_layers', 'num_neurons'])
最佳超参数设置为:
print([results[‘x_iters’][parameter][10] for parameter in results[‘x_iters’].keys()])>>> [0.5672132691312042, 1, 200]
因此，在给定迭代次数和主题数量的情况下，我们的搜索空间中的最佳设置是:
dropout: 0.5672num_layers: 1num_neurons: 200
结论
就是这样！如果您已经完成了这篇文章的结尾，那么现在您已经准备好优化您自己的主题模型了。您对选择参数/搜索空间的数量有基本的了解，并知道如何用 Python 编程。
我和我的研究小组开发了新的主题建模算法，这些算法已经发表在 2021 年计算智能系列研讨会上。初步结果表明，与 OCTIS 涵盖的主题模型相比，这些模型具有较高的可解释性。在以后的文章中，我将解释这些模型的工作原理，并将它们与 OCTIS 现有的主题模型进行比较。
祝你在 OCTIS 中优化你自己的主题模型好运，如果你有任何问题/意见，请不要犹豫联系我。
此外，这里的是到 Google Colab 的链接，其中一个 CTM 模型是由 OCTIS 开发人员优化的。
如果你喜欢这项工作，你可能会对主题建模感兴趣。在这种情况下，您可能也会对以下内容感兴趣。
我们创建了一个新的主题建模算法，叫做 FLSA-W (官方页面是这里是，但是你可以看到论文这里是)。
在几个开放数据集上，FLSA-W 的性能优于其他一流算法(如 LDA、ProdLDA、NMF、CTM 等)。 该作品 已提交，但尚未通过同行评审。
如果想用 FLSA-W，可以下载 的 FuzzyTM 包 或者 Gensim 中的 flsamodel。如需引用，请使用本文。
参考文献
[1]罗德，m .，两者，a .，&欣内堡，A. (2015 年 2 月)。探索话题连贯性测量的空间。第八届 ACM 网络搜索和数据挖掘国际会议论文集(第 399-408 页)。
面向数据科学的 Python 初学者指南
作为数据科学家应该学习的 11 个 Python 包
丹尼尔·伊德里在 Unsplash 上的照片
数据科学家每天都要执行各种各样的任务，包括数据收集、预处理、分析、机器学习和可视化。
如果您是数据科学行业的初学者，您可能上过 Python 或 R 课程，并且了解数据科学生命周期的基础知识。
然而，当你试图自己在 Kaggle 上试验数据集时，你可能会发现很难，因为你不知道从哪里开始。
你不知道该用什么工具来完成你想要完成的任务。
在本文中，我将带您了解一些对数据科学最重要的 Python 库。几乎所有你想执行的任务都有一个库，我将在这里分解其中的一些。
这些是大多数数据科学家日常使用的库(我在我的数据科学工作中使用它们)，所以知道如何使用它们是很重要的。
我还会列出一些免费资源(视频、文章和教程)供您浏览，以便获得使用这些库的实践经验。
数据收集
解决任何数据科学问题的第一步是数据收集。有时，这些数据会以 SQL 数据库或 Excel 表格的形式出现。在其他时候，您需要自己提取数据——要么使用 API，要么使用 web 抓取。
下面，我将列举一些 Python 中最常见的数据集合库。根据我需要收集的数据类型，我经常使用这些库，它们使我的数据科学工作流程变得更加容易。
MySQLConnector
如果您需要提取的数据是 SQL 数据库的形式，您需要在预处理和分析之前将数据库加载到 Python 中。
MySQLConnector 是一个库，允许您使用 Python 建立与 SQL 数据库的连接。
在这个库的帮助下，您可以轻松地加载数据库表，然后将表转换为 Pandas 数据框，以执行进一步的数据操作。
您还可以创建数据库，并在这个库的帮助下写入数据库。
MySQLConnector 入门:
美丽的声音
公司在制定业务决策时通常依赖外部数据，他们可能希望比较竞争对手产品的价格，分析竞争对手的品牌评论等。
BeautifulSoup 是一个 Python 库，可以帮助你从任何网页上抓取数据。
这里是一个帮助你入门 Python 中 BeautifulSoup 的教程。
社交媒体 API
Twitter、脸书和 Instagram 等社交媒体平台每天都会产生大量数据。
这些数据可用于许多数据科学项目，例如:
A 公司刚刚发布了一款产品，并推出了特别折扣。他们的客户对产品和折扣的反应如何？人们是否比平时更多地谈论该品牌？促销活动是否提高了品牌知名度？与竞争对手品牌相比，整体产品情感有多好？
对于一家公司来说，仅凭内部数据很难衡量整体品牌情绪(在大范围内)。
社交媒体分析在为客户流失预测和客户细分等任务收集数据方面发挥了巨大作用。
从社交平台收集数据并不困难，因为有很多公开可用的 API 可以帮助你快速完成这项工作。其中一些包括:
- 推特: Tweepy ， Twint
- 脸书:Python-脸书-API
- YouTube:Python-YouTube
以下是一些帮助您入门的教程:
这里的是我用 Twitter API 创建的一个情感分析项目的例子。
数据预处理
真实世界的数据是肮脏的。它并不总是以 Excel 表格或. csv 文件的格式出现。它可以是 SQL 数据库、文本文件、JSON 字典甚至 PDF 文件的格式。
作为一名数据科学家，你的大部分时间将用于创建数据框、清理数据框和合并数据框。
一些有助于数据准备的 Python 库包括:
Numpy
Numpy 是一个包，允许您对大量数据快速执行操作。
在 Numpy 的帮助下，您可以将数据框转换为数组，操作矩阵，并轻松找到人口的基本统计数据(如中位数或标准差)。
帮助您开始使用 Numpy 的一些教程:
熊猫
Pandas 是用于数据科学的最流行和最广泛使用的 Python 包之一。
在 Pandas 的帮助下，您可以轻松读取不同的文件类型并创建数据框。然后，您可以创建函数来快速预处理这些数据-您可以清理数据框，移除缺失/无效的值，并执行数据缩放/标准化。
要学习熊猫，你可以参加以下教程:
正则表达式
使用 Pandas 数据框时，您是否遇到过无效值、奇怪的符号或空格？
虽然 RegEx 不是专门为数据科学家构建的库，但是我将它添加到这个列表中，因为它非常有用。
您可以使用 RegEx(或正则表达式)来标识数据中的一组字符。该库可用于查找指定特定条件的数据行。它还可以用于预处理数据和删除与特定格式不匹配的无效值。
开始对 Pandas 数据框使用正则表达式的一些教程:
数据分析
执行数据分析的最重要的库是 Pandas。上面我已经解释了使用 Pandas 进行数据预处理，所以现在我将介绍 Pandas 中用于数据分析的最佳模块之一:
熊猫-侧写
熊猫概况是一个非常有用的数据分析模块。在数据框上运行 pandas-profiling 后，它将为您提供如下所示的数据统计摘要:
作者图片
它还为您提供了每个变量的描述，它们之间的相互关系，它们的分布和基数。
要了解更多关于熊猫简介的信息，请阅读这篇文章。
海生的
任何数据科学项目的另一个关键部分是可视化。重要的是要形象化变量的分布，检查它们的偏斜度，并了解它们之间的关系。
Seaborn 是一个可以用于此目的的库。它的导入速度很快，你可以很容易地制作图表，只需要一两行代码。
这里有一些学习资源可以帮助您开始使用 Seaborn:
这是我在 Seaborn 创建的数据可视化教程:
Plotly
Plotly 是我添加到这个列表中的另一个可视化库。使用 Plotly，您可以制作漂亮的交互式可视化效果。
定制 Plotly 可视化需要更多的代码和努力。
如果我想快速检查变量之间的分布/关系，我一般会使用 Seaborn。如果我需要向他人展示可视化，我会使用 Plotly，Plotly 的图表是交互式的，看起来很好。
Plotly 还允许您构建交互式 choropleth 地图，这使您可以轻松地绘制位置数据。如果您需要按地区、国家或纬度/经度显示数据，Plotly 的 choropleth 地图是最好的方法。
Plotly 入门的一些学习资源:
机器学习
Python 中最流行的机器学习库包括:
sci kit-学习
Scikit-Learn 是最广泛使用的用于机器学习的 Python 库。它允许您只需几行代码就可以构建线性回归、逻辑回归和决策树等机器学习算法。
你可以在这个教程的帮助下开始使用 Scikit-Learn。
这里的是我创建的一个线性回归教程，它使用 Scikit-Learn 来实现模型。
统计模型
Statsmodel 是另一个可以用来构建机器学习算法的 Python 库。
我更喜欢使用 Statsmodel 而不是 Scikit-Learn 的原因是因为它在建立机器学习模型后提供了详细的摘要。
只需一行代码，我们就可以查看标准误差、每个变量的模型系数和 p 值等指标。
这让我们对模型的性能有了一目了然的了解。
要开始使用 Statsmodel，您可以阅读以下文章:
结论
数据科学家的工作不会从构建机器学习模型开始，也不会从构建机器学习模型结束。
您应该能够在需要时从不同的来源提取数据，并在使用这些数据构建模型之前先清理/分析这些数据。在数据行业工作时，您应该知道如何执行端到端的数据科学工作流。
你需要知道如何收集和预处理数据，分析数据，并建立机器模型。
上面列出的 11 个包是用 Python 做这件事的一些最简单的方法。
一旦您熟悉了其中的一些包，您就可以开始使用它们来构建数据科学项目。这将有助于提高您的数据科学和编程技能。
机器学习中回归分析的初学者指南
回归分析用例子，插图，动画和备忘单解释。
背景:
为了理解回归背后的动机，让我们考虑下面这个简单的例子。下面的散点图显示了从 2001 年到 2012 年美国大学毕业生的数量。
作者图片
现在根据现有的数据，如果有人问你 2018 年有多少硕士毕业的大学生呢？可以看出，拥有硕士学位的大学毕业生人数几乎是随年份线性增长的。因此，通过简单的视觉分析，我们可以粗略估计这个数字在 200 万到 210 万之间。让我们看看实际数字。下图描绘了从 2001 年到 2018 年的同一个变量。可以看出，我们预测的数字与实际值大致相当。
作者图片
因为这是一个更简单的问题(用一条线来拟合数据)，我们的大脑很容易做到这一点。将一个函数拟合到一组数据点的过程称为回归分析。
什么是回归分析？
回归分析是估计因变量和自变量之间关系的过程。简而言之，它意味着在某种误差函数下，将选定的函数族中的一个函数拟合到采样数据。回归分析是用于预测的机器学习领域中最基本的工具之一。使用回归，您可以在可用数据上拟合一个函数，并尝试预测未来或持续数据点的结果。这种函数拟合有两个目的。
- 您可以估计数据范围内的缺失数据(插值)
- 您可以估计数据范围之外的未来数据(外推法)
回归分析的一些实际例子包括预测给定房屋特征的房屋价格、预测 SAT/GRE 分数对大学录取的影响、基于输入参数预测销售、预测天气等。
让我们考虑一下之前大学毕业生的例子。
- 插值:让我们假设我们可以访问一些稀疏的数据，我们知道每 4 年大学毕业生的数量，如下图所示。
作者图片
我们想估计一下在这之间的所有缺失年份的大学毕业生人数。我们可以通过对有限的可用数据点拟合一条线来做到这一点。这个过程叫做插值。
图 4 :作者图片
推断:假设我们可以获得 2001 年到 2012 年的有限数据，我们想预测 2013 年到 2018 年的大学毕业生人数。
作者图片
可以看出，拥有硕士学位的大学毕业生人数几乎是随年份线性增长的。因此，对数据集拟合一条线是有意义的。用这 12 个点来拟合一条线，然后在未来的 6 个点上测试这条线的预测，可以看出预测非常接近。
外推-预测未来看不见的价值-作者图片
从数学角度来说
回归分析的类型
现在让我们来讨论一下进行回归的不同方法。基于函数族(f_beta)和使用的损失函数(l ),我们可以将回归分为以下几类。
1.线性回归
在线性回归中，目标是通过最小化每个数据点的均方误差的和来拟合超平面(2D 数据点的线)。
从数学上来说，线性回归解决了以下问题
因此，我们需要找到 2 个用β表示的变量，它们将线性函数 f(参数化。).上图 4 中可以看到一个线性回归的例子，其中 P=5。该图还显示了β_ 0 =-90.798 和β_ 1 = 0.046 的拟合线性函数
2.多项式回归
线性回归假设因变量(y)和自变量(x)之间的关系是线性的。当数据点之间的关系不是线性时，它无法拟合数据点。多项式回归通过将 m 次多项式拟合到数据点来扩展线性回归的拟合能力。所考虑的函数越丰富，它的拟合能力就越好。从数学上讲，多项式回归解决了以下问题。
多项式回归的数学公式——作者图片
因此我们需要找到用β_ 0，…，β_ m 表示的(m+1)个变量。可以看出，线性回归是二次多项式回归的一个特例。
考虑下面一组绘制成散点图的数据点。如果我们使用线性回归，我们得到的拟合显然无法估计数据点。但是如果我们使用 6 次多项式回归，我们会得到更好的拟合，如下所示
【左】数据散点图— 【中心】对数据的线性回归— 【右】6 次多项式回归
由于数据点在因变量和自变量之间没有线性关系，线性回归无法估计良好的拟合函数。另一方面，多项式回归能够捕捉非线性关系。
3.里脊回归
岭回归解决了回归分析中的过度拟合问题。为了理解这一点，考虑与上面相同的例子。当在具有 10 个训练点的数据上拟合 25 次多项式时，可以看出它完美地拟合了红色数据点(下图中心)。但是这样做，它会损害中间的其他点(最后两个数据点之间的尖峰)。这一点可以从下图中看出。岭回归试图解决这个问题。它试图通过折衷训练点的拟合来最小化泛化误差。
【左】数据散点图— 【中心】25 次多项式回归— 【右】25 次多项式岭回归
从数学上讲，岭回归通过修改损失函数解决了以下问题。
函数 f(x)可以是线性的，也可以是多项式的。在没有岭回归的情况下，当函数过度拟合数据点时，学习到的权重往往相当高。岭回归通过在损失函数中引入权重(β)的缩放 L2 范数来限制正在学习的权重的范数，从而避免过拟合。因此，训练的模型在完美拟合数据点(学习的权重的大范数)和限制权重的范数之间进行权衡。比例常数α> 0 用于控制这种折衷。较小的 alpha 值将导致较高的范数权重和过拟合训练数据点。另一方面，大的 alpha 值将导致函数与训练数据点的拟合较差，但权重的范数非常小。仔细选择α的值将产生最佳的折衷。
4.套索回归
套索回归类似于岭回归，因为两者都被用作正则项来防止训练数据点上的过度拟合。但是套索还有一个额外的好处。它加强了学习权重的稀疏性。
岭回归将学习到的权重的范数强制为小，产生一组总范数减小的权重。大多数权重(如果不是全部的话)将是非零的。另一方面，LASSO 试图通过使大部分权重真正接近于零来找到一组权重。这产生了稀疏权重矩阵，其实现可以比非稀疏权重矩阵更节能，同时在拟合数据点方面保持相似的精度。
下图试图在上面的同一个例子中形象化这个想法。使用岭回归和套索回归来拟合数据点，并且以升序绘制它们相应的拟合和权重。可以看出，套索回归中的大部分权重确实接近于零。
作者图片
从数学上讲，LASSO 回归通过修改损失函数解决了以下问题。
LASSO 和岭回归的区别在于 LASSO 使用权重的 L1 范数而不是 L2 范数。损失函数中的这种 L1 范数倾向于增加学习到的权重的稀疏性。关于它如何加强稀疏性的更多细节可以在下面文章的章节 L1 正则化 中找到。
常数α> 0 用于控制学习权重中拟合和稀疏度之间的折衷。较大的α值会导致较差的拟合，但会导致学习到的权重集更稀疏。另一方面，较小的 alpha 值导致训练数据点的紧密拟合(可能会导致过度拟合)，但权重集不太稀疏。
5.弹性网络回归
ElasticNet 回归是脊和套索回归的组合。损失项包括权重的 L1 和 L2 范数以及它们各自的标度常数。它通常用于解决套索回归的局限性，例如非凸性。ElasticNet 增加了权重的二次惩罚，使其主要为凸形。
从数学上来说，ElasticNet 回归通过修改损失函数解决了以下问题。
6.贝叶斯回归
对于上面讨论的回归(frequentists 方法)，目标是找到一组解释数据的确定性权重值(β)。在贝叶斯回归中，我们不是为每个权重找到一个值，而是试图在假设先验的情况下找到这些权重的分布。
因此，我们从权重的初始分布开始，并根据数据，利用贝叶斯定理将分布推向正确的方向，贝叶斯定理基于可能性和证据将先验分布与后验分布相关联。
当我们有无限个数据点时，权重的后验分布在普通最小二乘解的解处变成一个脉冲，即方差接近零。
找到权重的分布而不是一组确定性值有两个目的
- 它自然可以防止过度拟合的问题，因此可以作为一个正则项
- 它提供了信心和权重范围，这比只返回一个值更有逻辑意义。
让我们用数学方法来表述这个问题，并说明它的解决方法。
让我们对具有均值 μ 和协方差σ的权重进行高斯先验，即
基于可用的数据 D，我们更新这个分布。对于手头的问题，后验概率将是具有以下参数的高斯分布
详细的数学解释可以在这里找到
让我们通过观察顺序贝叶斯线性回归，一次更新一个数据点的权重分布，来直观地理解它。如下图
贝叶斯回归基于输入数据(x，y)-作者提供的图片，在正确的方向上推动后验分布
随着每个数据点的包含，权重的分布变得更接近实际的基本分布。
下面的动画绘制了原始数据、预测的四分位间距、权重的边际后验分布以及考虑单个新数据点时每个时间步长的权重联合分布。可以看出，随着我们包括更多的点，四分位范围变得更窄(绿色阴影区域)，边际分布分布在两个权重参数周围，方差接近零，联合分布在实际权重处收敛。
动画贝叶斯回归——来源:www.MLinGIFS.aqeel-anwar.com
7.逻辑回归
在输出需要是给定输入的输出的条件概率的分类任务中，逻辑回归很方便。从数学角度来说，逻辑回归解决了以下问题
考虑下面的例子，其中数据点属于两个类别之一:{0(红色)，1(黄色)}，如下面的散点图所示。
[左]数据点散点图—[右]对以蓝色绘制的数据点进行逻辑回归
逻辑回归在线性或多项式函数的输出端使用 sigmoid 函数，将(♾️-♾️)的输出映射到(0，1)。然后使用阈值(通常为 0.5)将测试数据分为两类。
这看起来像是逻辑回归不是回归而是一种分类算法。但事实并非如此。你可以在艾德里安的帖子里找到更多关于 T2 的信息。
摘要
在本文中，我们研究了回归分析中的各种方法，它们的动机是什么以及如何使用它们。下面的表格和备忘单总结了上面讨论的不同方法。
回归分析摘要-按作者分类的图片
来源:http://www.cheatsheets.aqeel-anwar.com
奖金:
可以在下面的链接中找到这个主题和机器学习中许多其他重要主题的紧凑备忘单
https://medium.com/swlh/cheat-sheets-for-machine-learning-interview-topics-51c2bc2bab4f
如果这篇文章对你有帮助，欢迎鼓掌、分享和回复。如果想了解更多关于机器学习和数据科学的知识，关注我Aqeel an war，或者在LinkedIn上联系我。
Scikit-Learn 简单指南—用 Python 构建机器学习模型
Python 中的第一个 ML 模型。
如果你正在学习 Python，并且想开发一个机器学习模型，那么你要认真考虑的库是 scikit-learn。Scikit-learn(也称为 sklearn)是 Python 中使用的一个机器学习库，它提供了许多无监督和有监督的学习算法。
在这个简单的指南中，我们将创建一个机器学习模型，它将预测电影评论是正面还是负面的。这被称为二进制文本分类，将帮助我们探索 scikit-learn 库，同时从头构建一个基本的机器学习模型。这些是我们将在本指南中学习的主题。
**Table of Contents** 1\. [The Dataset and The Problem to Solve](#f4a3)
2\. [Preparing The Data](#8da5)
- [Reading the dataset](#f171)
- [Dealing with Imbalanced Classes](#c614)
- [Splitting data into train and test set](#610e)
3\. [Text Representation (Bag of Words)](#3283)
- [CountVectorizer](#867e)
- [Term Frequency, Inverse Document Frequency (TF-IDF)](#e16b)
- [Turning our text data into numerical vectors](#0085)
4\. [Model Selection](#660b)
- [Supervised vs Unsupervised learning](#4584)
- [Support Vector Machines (SVM)](#1629)
- [Decision Tree](#1a0d)
- [Naive Bayes](#68b4)
- [Logistic Regression](#e482)
5\. [Model Evaluation](#0364)
- [Mean Accuracy](#42ef)
- [F1 Score](#05ec)
- [Classification report](#4716)
- [Confusion Matrix](#02ad)
6\. [Tuning the Model](#9f73)
- [GridSearchCV](#bc36)
数据集和要解决的问题
在本指南中，我们将使用在 Kaggle 上提供的 50k 条电影评论的 IMDB 数据集。数据集包含两列(评论和观点),这将帮助我们确定评论是积极的还是消极的。
问题公式化:我们的目标是在给定一个电影评论(输入)的情况下，找到哪个机器学习模型最适合预测情绪(输出)。
准备数据
读取数据集
下载数据集后，确保文件与 Python 脚本位于同一位置。然后，我们将使用 Pandas 库来读取该文件。
import pandas as pddf_review = pd.read_csv('IMDB Dataset.csv')
df_review
注意:如果您没有本指南中使用的一些库，您可以在终端或命令提示符下轻松安装带有 pip 的库(例如 pip install scikit-learn)
数据集如下图所示。
作者图片
该数据集包含 50000 行；然而，为了在接下来的步骤中更快地训练我们的模型，我们将采用 10000 行的较小样本。这个小样本将包含 9000 个正面和 1000 个负面评论，以使数据不平衡(所以我可以在下一步教你欠采样和过采样技术)
我们将用下面的代码创建这个小样本。这个不平衡数据集的名称将是df_review_imb
df_positive = df_review[df_review['sentiment']=='positive'][:9000]
df_negative = df_review[df_review['sentiment']=='negative'][:1000]df_review_imb = pd.concat([df_positive, df_negative])
处理不平衡的班级
在大多数情况下，一个类有大量的数据，而其他类的观察数据要少得多。这就是所谓的不平衡数据，因为每个类的观测值数量不是均匀分布的。
让我们看看我们的df_review_imb 数据集是如何分布的。
作者图片
正如我们所见，在df_review_imb中正面评价多于负面评价，所以我们有不平衡的数据。
为了对数据进行重采样，我们使用了imblearn库。您可以对正面评价进行欠采样，也可以对负面评价进行过采样(您需要根据您正在处理的数据进行选择)。在这种情况下，我们将使用RandomUnderSampler
首先，我们创建一个新的RandomUnderSampler (rus)实例，我们添加random_state=0 只是为了控制算法的随机化。然后，我们通过用rus.fit_resample(x, y)拟合rus对不平衡数据集df_review_imb 进行重新采样，其中“x”包含必须采样的数据，而“y”对应于“x”中每个样本的标签。
在此之后，x和y 被平衡，我们将它存储在一个名为df_review_bal. 的新数据集中。我们可以用下面的代码比较不平衡和平衡的数据集。
IN [0]: print(df_review_imb.value_counts(‘sentiment’))
print(df_review_bal.value_counts(‘sentiment’))OUT [0]:positive 9000
negative 1000
negative 1000
positive 1000
如我们所见，现在我们的数据集是平均分布的。
注 1:如果使用RandomUnderSampler时出现以下错误
IndexError:只有整数、切片(
:)、省略号(…)、numpy.newaxis (None)和整数或布尔数组是有效的索引
您可以使用RandomUnderSampler的替代产品。尝试下面的代码:
如上所示，df_review_bal数据框架现在应该有 1000 条正面和负面评论。
注 2:通常在将数据分成训练集和测试集之前，我们应该清理数据。在本例中，数据已经被清除；然而，现实世界中的数据是不干净的，所以每当你需要清理数据时，请查看下面的指南，了解 Python 中数据清理的最佳实践。
将数据分为训练集和测试集
在我们处理数据之前，我们需要将它分成训练集和测试集。train数据集将用于拟合模型，而test数据集将用于在训练数据集上提供最终模型拟合的无偏评估。
我们将使用 sklearn 的train_test_split来完成这项工作。在这种情况下，我们将测试数据设置为 33%。
from sklearn.model_selection import train_test_splittrain, test = train_test_split(df_review_bal, test_size=0.33, random_state=42)
现在，我们可以在训练和测试集内设置自变量和因变量。
train_x, train_y = train['review'], train['sentiment']
test_x, test_y = test['review'], test['sentiment']
让我们看看它们各自的含义:
- train_x: 将用于训练模型的独立变量(review)。由于我们指定了
test_size = 0.33，来自数据的 67%的观察值将用于拟合模型。 - train_y: 该模型需要预测的因变量(情绪)或目标标签。
- test_x: 剩余的
33%个独立变量，将用于进行预测，以测试模型的准确性。 - test_y: 类别标签，将用于测试实际类别和预测类别之间的准确性。
文本表示(单词包)
分类器和学习算法期望数字特征向量，而不是原始文本文档。这就是为什么我们需要把我们的电影评论文本变成数字向量。有许多文本表示技术，如一键编码、单词包和 wor2vec。
对于这个简单的例子，我们将使用单词包(BOW ),因为我们关心文本评论中单词的频率；然而，单词的顺序无关紧要。表示单词包的两种常见方式是计数矢量器和词频、逆文档频率(TF-IDF)。在我们选择它们之前，我会给你一个简单易懂的演示，告诉你它们是如何工作的。
计数矢量器
CountVectorizer 给出了单词在文档中出现的频率。让我们考虑下面的句子。
review = [“I love writing code in Python. I love Python code”,
“I hate writing code in Java. I hate Java code”]
CountVectorizer 的表示如下所示，
作者图片
如你所见，矩阵中的数字代表每个单词在每次评论中被提及的次数。在这个例子中，像“爱”、“恨”和“代码”这样的词有相同的频率(2)。
术语频率，逆文档频率(TF-IDF)
TF-IDF 计算“权重”,它表示一个单词对文档集合(也称为语料库)中的一个文档有多重要。TF-IDF 值与单词在文档中出现的次数成比例地增加，并被语料库中包含该单词的文档的数量所抵消。
TF-IDF 的表示看起来像下面的图片，是我们之前使用的相同文本。
作者图片
与前面的例子不同，单词“code”与单词“love”或“hate”的权重不同。这是因为“代码”出现在两个评审中；因此，它的重量减少了。
将文本数据转化为数字向量
在我们的原始数据集中，我们希望识别正面评论和负面评论的唯一/代表性单词，因此我们将选择 TF-IDF。为了使用 TF-IDF 将文本数据转换成数字向量，我们编写了以下代码。
from sklearn.feature_extraction.text import TfidfVectorizertfidf = TfidfVectorizer(stop_words='english')
train_x_vector = tfidf.fit_transform(train_x)
train_x_vectorOut[0]: <1340x20625 sparse matrix of type '<class 'numpy.float64'>'
with 118834 stored elements in Compressed Sparse Row format>
在上面的代码中，我们创建了一个新的TfidfVectorizer(tfidf)实例，我们删除了英文停用词，然后拟合(查找模型的内部参数)并转换(将参数应用于数据)train_x(文本评论)
我们刚刚创建的train_x_vector是一个稀疏矩阵，有 1340 条评论和 20625 个单词(评论中使用的整个词汇)。您可以用下面的代码显示这个矩阵，就像我在上面的例子中使用的图片一样
pd.DataFrame.sparse.from_spmatrix(train_x_vector,
index=train_x.index,
columns=tfidf.get_feature_names())
但是，请记住，您会发现大量的“0 ”,因为它是一个具有 1340x20625 个元素的稀疏矩阵，其中只有 118834 个元素不同于“0”
最后，让我们也转换一下test_x_vector，这样我们可以稍后测试模型的准确性(我们不需要再次拟合tfidf ，因为我们已经用训练数据拟合过了。)
test_x_vector = tfidf.transform(test_x)
注意:我们可以更好地准备文本数据，以便通过使用标记化和移除我们认为不相关的多余单词(除了 CountVectorizer 和 Tfidf 默认具有的停用词表之外)来开发更好的模型。有关使用 Python 进行标记化的更多信息，请查看下面的文章。
</5-simple-ways-to-tokenize-text-in-python-92c6804edfc4>
型号选择
现在我们有了数字数据，我们可以用不同的机器学习模型进行实验，并评估它们的准确性。
监督与非监督学习
机器学习算法分为有监督学习和无监督学习。在第一种模式中，使用标记数据训练模型，而在第二种模式中，从未标记的输入数据中推断模式。
在我们的例子中，我们的输入(评论)和输出(情绪)被清楚地识别，所以我们可以说我们已经标记了输入和输出数据；因此，我们正在处理监督学习。两种常见的监督学习算法是回归和分类。
- 回归:它们用于预测连续值，如价格、工资、年龄等
- 分类:用于预测离散值，如男性/女性、垃圾/非垃圾、正/负等。
也就是说，现在很明显我们应该使用分类算法。我们将对以下四个分类模型进行基准测试。
注意:我将把每个模型背后的理论留给你去研究。我将把重点放在代码上，以及我们如何根据分数选择最佳模型。
支持向量机(SVM)
为了适应 SVM 模型，我们需要引入输入(作为数字向量的文本评论)和输出(情感)
from sklearn.svm import SVCsvc = SVC(kernel=’linear’)
svc.fit(train_x_vector, train_y)
拟合svc 后，我们可以用.predict() 方法预测评论是正面还是负面。
print(svc.predict(tfidf.transform(['A good movie'])))
print(svc.predict(tfidf.transform(['An excellent movie'])))
print(svc.predict(tfidf.transform(['I did not like this movie at all'])))
如果您运行上面的代码，您将获得第一个和第二个评论是正面的，而第三个是负面的。
决策图表
为了适应决策树模型，我们需要引入输入(作为数字向量的文本评论)和输出(情感)
from sklearn.tree import DecisionTreeClassifierdec_tree = DecisionTreeClassifier()
dec_tree.fit(train_x_vector, train_y)
朴素贝叶斯
为了适应朴素贝叶斯模型，我们需要引入输入(作为数字向量的文本评论)和输出(情感)
from sklearn.naive_bayes import GaussianNBgnb = GaussianNB()
gnb.fit(train_x_vector.toarray(), train_y)
逻辑回归
为了拟合逻辑回归模型，我们需要引入输入(作为数字向量的文本评论)和输出(情感)
from sklearn.linear_model import LogisticRegressionlog_reg = LogisticRegression()
log_reg.fit(train_x_vector, train_y)
模型评估
在本节中，我们将看到用于评估模型的传统指标。
平均准确度
要获得每个模型的平均准确度，只需使用如下所示的测试样本和真实标签的.score方法。
# svc.score('Test samples', 'True labels')svc.score(test_x_vector, test_y)
dec_tree.score(test_x_vector, test_y)
gnb.score(test_x_vector.toarray(), test_y)
log_reg.score(test_x_vector, test_y)
在打印出每一个之后，我们得到平均精度。
SVM: 0.84
决策树:0.64
朴素贝叶斯:0.63
逻辑回归:0.83
SVM 和逻辑回归比其他两个分类器表现更好，SVM 略有优势(84%的准确率)。为了展示其他指标的工作原理，我们将只关注 SVM。
F1 分数
F1 分数是精确度和召回率的加权平均值。当真阳性和真阴性更重要时使用准确度，而当假阴性和假阳性至关重要时使用 F1 分数。此外，F1 还考虑了数据的分布方式，因此当您有不平衡类的数据时，F1 非常有用。
F1 分数通过以下公式计算。(如果你不知道精度和召回意味着什么，查看一下这个关于 stackoverflow 的精彩解释)
F1 Score = 2*(Recall * Precision) / (Recall + Precision)F1 score reaches its best value at 1 and worst score at 0.
为了获得 F1 分数，我们需要真实标签和预测标签f1_score(y_true, y_pred)
from sklearn.metrics import f1_scoref1_score(test_y, svc.predict(test_x_vector),
labels=['positive', 'negative'],
average=None)
阳性标签的得分为 0.84，而阴性标签的得分为 0.83。
分类报告
我们还可以构建一个文本报告，显示主要的分类指标，包括之前计算的指标。为了获得分类报告，我们需要真实标签和预测标签classification_report(y_true, y_pred)
from sklearn.metrics import classification_reportprint(classification_report(test_y,
svc.predict(test_x_vector),
labels=['positive', 'negative']))
打印后，我们获得以下报告。
precision recall f1-score support
positive 0.83 0.87 0.85 335
negative 0.85 0.82 0.83 325
accuracy 0.84 660
macro avg 0.84 0.84 0.84 660
weighted avg 0.84 0.84 0.84 660
正如我们所见，精确度和 f1 分数与之前计算的相同。
混淆矩阵
混淆矩阵)是允许算法性能可视化的表格。该表通常有两行和两列，报告假阳性、假阴性、真阳性和真阴性的数量(如果您不理解这些术语，请查看此链接中的图表)
为了获得混淆矩阵，我们需要真实标签和预测标签。
from sklearn.metrics import confusion_matrixconf_mat = confusion_matrix(test_y,
svc.predict(test_x_vector),
labels=['positive', 'negative'])
运行下面的代码后，我们将获得下面的数组作为输出。
array([[290, 45],
[ 60, 265]])
要理解这意味着什么，请查看下面的图片。
如您所见，数组的每个元素代表混淆矩阵中的四个方块之一(例如，我们的模型检测到 290 个真阳性)
调整模型
最后，是时候最大化我们模型的性能了。
GridSearchCV
这种技术包括对特定参数的彻底搜索，以便获得超参数的最佳值。为此，我们编写以下代码。
from sklearn.model_selection import GridSearchCV#set the parameters
parameters = {‘C’: [1,4,8,16,32] ,’kernel’:[‘linear’, ‘rbf’]}
svc = SVC()
svc_grid = GridSearchCV(svc,parameters, cv=5)
svc_grid.fit(train_x_vector, train_y)
正如你所看到的代码，它与我们为适应 SVM 模型而编写的代码没有太大的不同；然而，现在我们指定一些参数来获得最佳模型。
在拟合模型之后，我们用下面的代码获得了最好的分数、参数和估计量。
IN [0]: print(svc_grid.best_params_)
print(svc_grid.best_estimator_)OUT [0]: {'C': 1, 'kernel': 'linear'}
SVC(C=1, kernel='linear')
就是这样！现在您已经准备好使用 sklearn 创建自己的机器学习模型了！本指南所写的所有代码都可以在我的 Github 上找到。
下面你可以找到一些我用 Python 做过的项目。
https://medium.datadriveninvestor.com/can-we-beat-the-bookies-predicting-football-games-with-a-simple-model-43fe020fb384 https://medium.com/swlh/web-scraping-basics-scraping-a-betting-site-in-10-minutes-8e0529509848
与 3k 以上的人一起加入我的电子邮件列表，获取我在所有教程中使用的 Python for Data Science 备忘单(免费 PDF)
Django 面向数据科学家——Django 和 Django for 简介
使用 Django ORM 完成数据管理任务。甚至不需要启动任何 web 服务器。
作者图片
Django 作为高级 Web 框架的广泛特性集可能会吓跑那些从未真正接触过 Web 开发的数据分析师和数据科学家。不幸的是，这可能会让他们无法体验 Django 令人印象深刻且易于使用的数据管理能力。
虽然大多数 Django 教程在几个小时的视频片段中涵盖了所有的功能，但我想集中强调一下 Django 强大的数据库交互特性，而不会让读者对几乎无限的特性集感到过载。本文应该尽可能简单地解释它，这样您就可以使用 Django 来完成您的数据管理任务，而不必了解 Django 的每一个细节。但是为什么要使用 Django 呢？
使用 Django 进行数据管理的 4 个简单原因:
- 使用您熟悉的语言:Django ORM 允许您在不使用任何 SQL 命令的情况下与数据库进行交互
- 一切尽在一处:在与数据库交互时，只需使用 Python 提供的惊人的数据处理、数据管理和数据可视化功能和模块
- Django 附带了一个强大的内置数据库管理 GUI——Django Admin
- 如果你想将数据库中的数据可视化，并在应用程序中分享，Django 可以满足你的一切需求
目录
- 简短介绍—什么是 Django 和 Django ORM？
- 与您的数据库交互的先决条件—安装 Django，启动一个项目并将其连接到您的数据库
- 在独立的 python 脚本中使用 Django ORM
- 简短介绍:作为 Web 框架的 Django
- Django Admin——用于数据管理的内置网络界面
- 总结
简短介绍—什么是 Django 和 Django ORM？
Django 是一个 Python Web 框架，它帮助开发人员尽可能快地将应用程序从概念变为现实。像 Django 这样的高级框架为 web 开发提供了一套全面的特性，如 HTTP 应用服务器、数据库之类的存储机制、模板引擎、请求调度程序和认证模块。
正如我之前提到的，我试图将重点放在 Django 中允许您与关系数据库交互的部分，即对象关系映射器(ORM) 。ORM 为您提供了创建和操作数据库中的数据和表格的所有功能，而无需使用任何 SQL 命令。⁴
我试图用下图解释的是，每个 Django 应用程序都包括一个名为mocels.py的模块，它定义了您想要创建的数据库表的结构。为了将 Python 对象转换成数据库表，ORM 应运而生。ORM 负责与数据库的通信，包括将您定义的模型翻译成正确的数据库结构，以及执行任何数据库操作。
Django ORM:从 Python 类到数据库表——作者图片
与数据库交互的先决条件——安装 Django，启动一个项目并将其连接到数据库
如果您不熟悉 Django，可以用 pip 和下面的命令安装它:
python -m pip install Django
当您使用Django-admin开始一个新项目时，已经为您自动生成了许多文件和代码，为您提供了基本结构、示例模板和默认配置。在命令行中，导航到您想要用作项目文件夹位置的文件夹，并运行以下命令，以启动项目data_management:
django-admin startproject data_management
Django-admin startproject创建一组文件，主要决定 Django 项目的基本配置。因为我们将在下面主要使用 Django 的 ORM，我们现在可以忽略这些设置。
作者图片
您刚刚创建的项目文件夹代表了您要移入的环境。为了让您的项目能够真正做一些事情，您仍然需要实际的 web 应用程序。这是在manage.py的帮助下实现的，它让你有可能与你的项目互动。要创建您的第一个应用程序，只需确保您位于项目文件夹中，并执行以下命令:
python manage.py startapp data_processig
最后两步将创建以下项目结构。
Django 项目文件夹结构—作者图片
要告诉您的项目使用哪些应用程序，您仍然需要在settings.py中注册您的应用程序。将创建的应用程序data_processing_app添加到列表INSTALLED_APPS中:
#settings.pyINSTALLED_APPS = [
'django.contrib.admin’,
'django.contrib.auth’,
'django.contrib.contenttypes’,
'django.contrib.sessions’,
'django.contrib.messages’,
'django.contrib.staticfiles’,
'data_processing_app'
]
将 Django 连接到 MySQL
在我们深入了解 Django ORM 的更多细节之前，我们首先需要一个到我们选择的数据库的链接，在我的例子中是 MySQL。首先，我们需要确保安装了所需的 MySQL DB API 驱动程序。Django 推荐的选择是 mysqlclient 。⁵
pip install mysqlclient
在下面的代码中，您将 Django 链接到一个现有的数据库，因此您必须首先创建一个新的数据库/模式。我创建的模式的名称是personal_dashboard。
作者图片
要将 Django 连接到您的 MySQL 和正确的数据库，您必须在settings.py中定义连接参数:
Django 设置:定义您想要使用的数据库—图片由作者提供
就是这样，姜戈应该连接到你的数据库！测试它的一个简单方法就是使用python manage.py runserver。这个命令将在本地机器上运行一个轻量级的开发 Web 服务器。在这个过程中，Django 会检查设置，并告诉您是否无法建立到数据库的连接。
创建第一个模型
去models.py创建一个新模型。该模型稍后将表示数据库中的表。为了让它更有趣一点，让我用一个例子来展示它。
我用一个叫做 Toggl Track 的工具来跟踪我的工作时间。为了将这些记录用于我自己的可视化和计算，Toggl 提供了一个 API，允许我查询这些数据。API 返回的数据大致具有以下结构:
作者图片
在下文中，我将尝试在我自己的数据库中重现该结构。表 workspaces 只包含 workspace-id wid和工作空间的名称。要通过 Django 映射表，请转到models.py并创建一个新类。
首先创建一个保存工作空间信息的模型。稍后，您将在数据库表中找到 Python 类/模型的名称。创建的表格的全名由<appname>_<modelname>组成，对于这里显示的情况，表格采用以下名称:data_processing_app_toggl_workspaces
要向表中添加字段/列，请添加具有适当字段类型的字段。您可以在 Django 文档中找到所有字段类型的摘要。在这种情况下，我们只需要一个保存workspacesID 的整数字段和一个保存工作空间名称的字符字段。要对数据库进行更改，您需要运行以下两个命令。
python manage.py makemigrations，它基于您对模型所做的更改来创建新的迁移python manage.py migrate，应用迁移
在您成功执行这两个命令之后，表data_processing_app_toggl_workspaces 应该会出现在您的数据库中。
作者图片
接下来，我需要一个模型，稍后我将用clients模型填充它。每个客户端都被分配到一个工作区。由于每个工作空间通常有多个客户端，这是一个多对一的关系，它是在 Django 中使用ForeignKey字段建立的。
作者图片
类似地，执行其他表的创建和链接。下面的代码展示了所有必需的表到 Django 模型的映射。
用一个独立的脚本填充数据库
如果您想在没有 web 服务器的情况下使用 Django 功能，您必须将settings.py设置为环境变量并使其可访问。这可以通过在脚本的开头添加以下行来实现:
import os
import django
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'data_management.settings')
django.setup()
现在为刚刚生成的表data_processing_app_toggl_workspaces创建一个新条目，首先为您的toggl_workspaces类创建一个新对象:
new_workspace = models.toggl_workspaces(wid="12512465",
name="test_workspace")
用.save()将新条目保存到数据库中。
new_workspaces.save()
以下脚本将样本数据框的内容存储在相应的表中。
为了能够在网站上显示、评估和可视化您的数据，下一段将向您展示 HTML 页面和数据库之间的通信是如何发生的。
简短介绍:作为 Web 框架的 Django
如前所述，在这里我不想太深入地把 Django 作为一个 web 框架。尽管如此，我认为对 Django 模块及其功能有一个共同的理解是有用的。下图描述了项目结构的各个组件是如何相互关联的。显示的请求-响应循环只显示了流程的简化形式，不包含使用的中间件，但它将刚刚创建的文件放入了一个粗略的上下文中。
Django 请求-响应循环—作者图片
传入的请求主要由中间件处理，为了简单起见，图中省略了中间件。Django 已经包含了一些内置的中间件，比如 AuthenticationMiddleware、CsrfViewMiddleware 或 SessionMiddleware。每个人都负责一项特定的任务。⁶
您可以在settings.py中找到二手中间件列表:
作者图片
在 WSGI (Web 服务器网关接口)和第一个 Middlewares⁷(如安全和认证中间件)之后，请求将到达 url 路由器，它使用 in urls.py 定义的变量urlpatterns并寻找与请求中的 URL 匹配的 urlpattern。⁸
如前所述，您可以使用命令python manage.py runserver在本地机器上启动一个 web 服务器。除非另有说明，否则本地 web 服务器运行在端口 8000 和地址 127.0.0.1 上。因此，如果您在浏览器中调用地址http://127 . 0 . 0 . 1:8000/example，Django 会在 urlpatterns 列表中搜索条目‘example。本例中的 URL 路由器指向您第一个创建的应用程序data_processing_app中views.py中的函数example。
函数render用于组合给定的上下文字典和 HTML 模板，并返回一个HttpResonse。⁹在这个例子中，我将变量test_string传递给我的模板。或者，我有可能从我的数据库传递数据到我的 HTML 模板。我将在下面解释这是如何工作的。
Django 请求-响应循环—作者图片
现在，从数据库中访问数据并在 HTML 模板中使用它变得非常简单。
从数据库中检索数据
为了能够在下面从数据库中检索数据，我们通过模型类上的管理器构造了一个 queryset。⁰管理器描述了允许你执行数据库查询操作的界面。每种型号至少有一个名为objects的经理。
要返回数据库中的所有对象，使用all()方法。因此，如果您将all()方法应用于模型time_entries的objects管理器，您将获得一个包含数据库中所有条目的 QuerySet。
import data_processing_app.models as modelsQuerySet = models.time_entries.objects.all()
要构建和测试您的查询，您可以使用manage.py shell。使用命令python manage.py shell启动一个新的 shell 后，您需要导入您的模型(import data_processing_app.models as models)。现在，您可以创建一个新的查询集。
作者图片
为了能够在 HTML 页面上显示这个查询，您必须将它包含在您的请求的上下文中。为此，在视图的相应函数中包含字典context中的 QuerySet 就足够了。在您的 HTML 中，您可以使用{{ <variable_name> }}简单地输出传递的值。
下图显示了我们使用的示例。
Django 请求-响应循环—作者图片
Django 附带了许多操作和创建 QuerySets 的方法。您将在 Django 文档中找到全面的文档。提前这么多，几乎没有什么是不可能的。查询可以根据需要进行扩展和细化。
这里只是一个例子，我用它来过滤客户端Dans Computer Service在time_entries中的条目，然后按日历周对客户端的所有条目的持续时间求和。通过这种方式，我可以计算出我每周为某个客户工作的时间。
第一步是通过表toggl_clients中的字段name过滤表time_entries。由于表是通过外键project和client连接的，您可以通过:
queryset = models.time_entries.objects.filter(project__client__name="Dans Computer Service")
现在，计算每周的总小时数:要生成每个对象的摘要，可以使用annotate()子句。我在下面使用.annotate()来计算每个日历周的duration的总和。
queryset_sum_week = QuerySet.annotate(week=ExtractWeek('start')).values('week') .annotate(week_total=Sum('duration') / 3600).order_by('week')
这会产生以下 QuerySet，其中包含日历周的条目以及该周所有条目的持续时间总和。
作者图片
为了不超出本文的范围，我不想详细讨论这个问题，但是您会发现 Django 文档中的所有方法都能够按照您的意愿构建您的查询。
下一段将向您展示 Django 最重要的数据管理工具，一个用于维护数据的集成用户界面。
django Admin——用于数据管理的内置 Web 界面
Django Admin 是一个强大的内置特性。它提供了一个包含所有模型元数据的接口，并使您能够轻松管理数据库条目。“组”和“用户”表由自动创建。在Users中，你可以直接创建新用户，并赋予他们适当的访问权限。对 Django Admin 的访问被授予所谓的超级用户和职员用户。
Django 请求-响应循环—作者图片
如果您是第一次启动这个站点，并且还没有创建用户，您可以使用命令python manage.py createsuperuser创建一个超级用户，然后登录 Django admin。
作者图片
如果您已经在admin.py中注册了您的模型，您可以在管理区域中管理您的表的所有条目，并且还可以创建新的条目。Django Admin 是经过深思熟虑的，不需要任何开发工作就可以使用。
作者图片
摘要
我试着解释了在数据库中创建表、填充表、生成查询和通过 Django Admin 维护数据所需的所有 Django 功能。
出于性能原因，当然有理由不使用 Python 和 Django 进行大量数据的操作。但是，Django 提供了所有的功能，以一种简单、可理解和 pythonic 化的方式与数据库进行交互。特别是最后一点，为您打开了一个全新的数据分析、数据科学和数据可视化的世界。Python 为您提供了一个巨大的数据分析和可视化工具宝库，让您有机会发现数据中的一两个细节。
我希望这篇文章能给你一个快速简单的 Django 介绍，并展示 Django 不仅是一个强大的 web 开发工具。
感谢阅读！
参考
[1]遇见姜戈，【https://www.djangoproject.com/
[2]Python 的 Web 框架，【https://wiki.python.org/moin/WebFrameworks
[3]姜戈·奥姆，https://www.fullstackpython.com/django-orm.html
[4]凯蒂·麦克劳克林，《Django ORM 介绍》，https://opensource.com/article/17/11/django-orm
[5]数据库，https://docs . django project . com/en/3.1/ref/Databases/# MySQL-notes
[6]中间件，https://docs . django project . com/en/3.1/topics/http/Middleware/
[7]网址调度员，https://docs.djangoproject.com/en/3.1/topics/http/urls/
[8] Django 请求-响应周期——易于遵循的指南，https://data-flair . training/blogs/Django-请求-响应周期/
[9] Django 快捷函数，https://docs . Django project . com/en/3.1/topics/http/shortcut s/
[10]提出疑问，https://docs.djangoproject.com/en/3.1/topics/db/queries/
[11]经理姓名，https://docs . django project . com/en/3.1/topics/db/managers/# django . db . models . Manager
NLP 入门——构建垃圾邮件分类器
如果您不熟悉自然语言处理这个激动人心的世界，请从这里开始
内森·迪菲斯塔在 Unsplash 上拍摄的照片
单词、句子、段落和短文。我们成年后几乎每天都在使用它们。无论你是在发推文，给你的同事写电子邮件，还是像我现在这样写文章，作为人类，我们都用文字来交流我们的思想和想法。
现在，想象一个世界，在那里我们可以教计算机与文字互动，就像我们与另一个人互动一样。想象一下这样一个世界，计算机不仅能够检测人类的语言，更重要的是，能够学习语言的细微差别，从而得出给定信息的潜在含义或意图。
这正是自然语言处理(NLP)的全部内容。
介绍
NLP 指的是人工智能领域，通过自然语言处理计算机和人类之间的交互。这包括使计算机能够操纵、分析、解释以及生成人类语言。
我最近花了一些时间涉猎了一些 NLP 的基础知识，我想用这篇文章不仅分享我所学到的东西，而且进一步加强我对这个主题的理解。具体来说，这篇文章的灵感来源于NLP with Python for Machine Learning Essential Training，一个由 Derek Jedamski 给出的 LinkedIn 课程。
我想在此对 Derek 的工作给予充分的肯定和参考，并强烈推荐查看他在 Python 中关于机器学习的其他课程。
我写这篇文章的目的是重新创建在课程中介绍的主要项目，即使用垃圾短信收集数据集构建的垃圾短信(二进制)分类器，该数据集包含一组 5，572 条英文短信。一旦准备就绪，分类器将能够读取给定的文本字符串，并随后将文本分类为火腿或垃圾邮件。
在本文中，我将介绍构建垃圾邮件分类器的步骤，并重点介绍自然语言处理中的一些关键概念。如果你想继续下去，这个项目的代码可以在我的 GitHub 这里找到。
事不宜迟，我们开始吧！
GIF by GIPHY
1.探索性数据分析
像任何专业的数据科学家一样，让我们从探索数据集开始。
探索性数据分析是对数据进行初步调查的过程，以发现模式、发现异常、测试假设并借助汇总统计和图形表示检查假设(定义归功于 Prasad Patil 的“什么是探索性数据分析”)。
data = pd.read_csv("spam.csv", encoding = "latin-1")
data = data.dropna(how = "any", axis = 1)
data.columns = ['label', 'body_text']
data.head()
输入数据有 5572 行(每行代表一个唯一的文本消息)和 2 列:标签和 body_text。在 5572 行中，有 747 行是垃圾邮件，剩下的 4825 行是火腿。我们也没有丢失数据，耶！
让我们使用 seaborn 来更直观地表示我们的输入数据。
total = len(data)
plt.figure(figsize = (5, 5))
plt.title("Number of spam vs ham messages")
ax = sns.countplot(x = 'label', data = data)
for p in ax.patches:
percentage = '{0:.0f}%'.format(p.get_height() / total * 100)
x = p.get_x() + p.get_width() / 2
y = p.get_height() + 20
ax.annotate(percentage, (x, y), ha = 'center')
plt.show()
如我们所见，垃圾邮件(87%)明显多于垃圾邮件(13%)。
从技术上讲，在这个阶段，我们应该关注与不平衡数据集相关的问题。然而，为了简单起见，我们暂时忽略这一点。
2.特征工程
特征工程是创建新特征和/或改造现有特征以充分利用数据的过程。
在本节中，我们将创建两个新功能:
- body_len: 正文的长度，不包括空格
- 点%正文中标点符号的百分比
# body_len
data['body_len'] = data.body_text.apply(lambda x: len(x) - x.count(" "))# punct%
def count_punct(text):
count = sum([1 for char in text if char in string.punctuation])
return round(count/(len(text) - text.count(" ")), 3) * 100 data[‘punct%’] = data.body_text.apply(lambda x: count_punct(x))
现在，我们可以继续使用新创建的要素来探索输入数据的分布。
bins = np.linspace(0, 200, 40)
data.loc[data.label == 'spam', 'body_len'].plot(kind = 'hist', bins = bins, alpha = 0.5, density = True, label = 'spam')
data.loc[data.label == 'ham', 'body_len'].plot(kind = 'hist', bins = bins, alpha = 0.5, density = True, label = 'ham')
plt.legend(loc = 'best')
plt.xlabel("body_len")
plt.title("Body length ham vs spam")
plt.show()
正如我们所见，与垃圾邮件相比，垃圾邮件的正文长度更长，即包含更多的单词。
那么，标点符号的百分比呢？
bins = np.linspace(0, 50, 40)
data.loc[data.label == 'spam', 'punct%'].plot(kind = 'hist', bins = bins, alpha = 0.5, density = True, label = 'spam')
data.loc[data.label == 'ham', 'punct%'].plot(kind = 'hist', bins = bins, alpha = 0.5, density = True, label = 'ham')
plt.legend(loc = 'best')
plt.xlabel("punct%")
plt.title("Punctuation percentage ham vs spam")
plt.show()
在这里，这两种分布看起来非常相似，尽管业余爱好者的消息似乎有一个更长的尾巴，即业余爱好者的消息往往有更高的标点符号百分比。
3.清理文本
如果您有任何处理真实世界数据的经验，您会知道真实世界的数据通常非常混乱，并且不容易处理。这个也不例外。
在我们能够实际建模和预测数据之前，还有很多工作要做。更具体地说，为了让我们更好地管理杂乱的文本消息，我们将需要执行以下预处理步骤(这些步骤非常特定于 NLP 管道):
- 将单词转换成小写字母
- 删除标点符号和停用词
- 符号化
- 词干与词汇匹配(文本规范化)
让我们逐一调查每个步骤。
3.1 将单词转换成小写字母
Python 并不认为所有字符都是平等的。为了保持一致，我们需要将所有单词转换成小写字母。例如，Python 将向下面的第一条语句返回 False，但向第二条语句返回 True。
# False statement
"NLP" == "nlp"# True statement
"NLP".lower() == "nlp"
3.2 删除标点符号
与上面的论点相似，去掉标点符号的理由是因为标点符号在文本中没有任何意义。因此，我们希望 Python 只关注给定文本中的单词，而不用担心涉及的标点符号。
下面举个例子。
# False statement
"I love NLP" == "I love NLP."
作为人类，我们可以立即看出上面的两段文字几乎完全相同，除了第二段在句尾有一个句号。
但是，Python 将无法区分这两种文本。出于这个原因，为了让 Python 更清楚地解释文本，我们删除句子中的所有标点符号是很重要的。
您可以通过键入以下内容找到存储在 Python 中的字符串库中的标点符号列表:
string.punctuation
为了去掉句子中的标点符号，我们可以如下使用列表理解:
# Original text
text = 'OMG! Did you see what happened to her? I was so shocked when I heard the news. :('# List comprehension to remove punctuation
text = "".join([word for word in text if word not in string.punctuation])
3.3 令牌化
在 NLP 的上下文中，标记化意味着将一个字符串或一个句子转换成一个字符列表，我们可以通过利用 Python 中的正则表达式(re) 库来实现这一点。
库中两个最简单的命令包括:
- 重新拆分
- 重新发现
如果你有兴趣知道它们是如何工作的，我鼓励你查看我的笔记本以了解更多细节。
3.4 删除停用词
停用词是英语中常用的词，如但是、 if 和 the 对句子的整体意思没有太大贡献。因此，为了减少 Python 在构建我们的机器学习模型时需要存储和处理的令牌数量，通常会删除停用词。
停用词存储在 nltk.corpus.stopwords 中，可通过以下方式访问:
stopwords = nltk.corpus.stopwords.words('english')
stopwords
要删除给定字符串中的停用词，我们可以再次应用列表理解。
# Original text
text = 'OMG Did you see what happened to her I was so shocked when I heard the news'
print(text)# Convert text into list of words in lowercase letters
print(text.lower().split())# List comprehension to remove stopwords
print([word for word in text.lower().split() if word not in stopwords]
运行上面的代码片段后，以下停用词将被删除。
- 做
- 你们
- 什么
- 到
- 她
- 我
- 是
- 因此
- 当...的时候
- 这
请注意，在运行列表理解之前，我们首先将原始文本转换为小写单词列表。这是因为单词在 nltk 库中是以小写字母存储的。
3.5 词干化与词汇化(单词规范化)
词干化:通过粗略地砍掉词尾，只留下词根，把词干或词根的词形变化或派生词减少到词干或词根的过程。
词汇匹配:把一个词的屈折形式组合在一起，使它们可以作为一个词来分析的过程。
从广义上讲，词干分析和词目分析都是为了将同一个单词的变体浓缩到它们的词根形式。这是为了防止计算机存储它在单词语料库中看到的每一个独特的单词，而是只记录一个单词的最基本形式，并将其他具有类似含义的单词关联起来。
比如成长、成长、成长、成长都是成长一词的简单变体。在这种情况下，计算机只需要记住单词 grow 而不需要记住其他的。
要访问词干分析器和 lemmatiser:
ps = nltk.PorterStemmer()
wn = nltk.WordNetLemmatizer()
斯特梅尔采用了一种比 lemmatiser 更为粗糙的方法，即在不知道单词使用的上下文的情况下，使用启发式方法简单地切断单词的结尾。因此，词干分析器有时不能返回词典中的实际单词。
另一方面，Lemmatiser 将总是返回一个字典单词。Lemmatiser 在简化一个给定的单词之前考虑了多个因素，通常更准确。然而，这是以比词干分析器更慢和计算量更大为代价的。
3.6 将所有内容放在一个 clean_text 函数中
太棒了，现在我们已经理解了文本清理的所有预处理步骤，我们想把所有东西总结成一个名为 clean_text 的函数，然后我们可以将它应用到我们的输入数据中。
# Create function for text cleaning
def clean_text(text):
text = "".join([word.lower() for word in text if word not in string.punctuation])
tokens = re.findall('\S+', text)
text = [wn.lemmatize(word) for word in tokens if word not in stopwords]
return text# Apply function to body_text
data['cleaned_text'] = data['body_text'].apply(lambda x: clean_text(x))
data[['body_text', 'cleaned_text']].head(10)
从那里，我们可以计算出在垃圾邮件中最常见的单词。
4.矢量化
矢量化是将文本编码为整数以创建特征向量的过程。
在本节中，我们将在 scikit-learn 中查看三个不同的文本矢量化函数:
- 计数矢量器
- tfidfttransformer
- tfidf 矢量器
4.1(计数矢量器+ TfidfTransformer)的工作原理
CountVectorizer 创建一个文档术语矩阵，其中每个单元的条目将是该单词在该文档中出现的次数的计数。
TfidfTransformer 类似于 CountVectorizer，但单元格不是代表计数，而是代表一个权重，用于确定一个单词对单个文本消息的重要性。计算每个像元权重的公式如下:
TF-IDF 下的加权计算公式
为了证明这一点，让我们看一个例子。
# CountVectorizer
corpus = ['I love bananas', 'Bananas are so amazing!', 'Bananas go so well with pancakes']
count_vect = CountVectorizer()
corpus = count_vect.fit_transform(corpus)
pd.DataFrame(corpus.toarray(), columns = count_vect.get_feature_names())
数据帧中的每一行代表一个句子(文档),每一列代表整个语料库中唯一的词，不包括停用词。例如，在惊人的、是、香蕉和所以列中，“香蕉如此神奇”的值为 1(其他的为 0)，因为这些单词中的每一个在特定的句子中都出现过一次。
另一方面，TfidfTransformer 的工作方式如下:
# TfidfTransformer
tfidf_transformer = TfidfTransformer()
corpus = tfidf_transformer.fit_transform(corpus)
pd.DataFrame(corpus.toarray(), columns = count_vect.get_feature_names())
回想一下，TF-IDF 中的单元格表示一个单词对一条单独的文本消息的重要性的权重。
我们以香蕉栏目为例。虽然单词 bananas 在三个句子的每一个中只出现一次，但是与第二个和第三个相比，第一个句子被赋予更高的权重，因为第一个句子具有最短的长度。换句话说，单词香蕉在第一句中比在第二句和第三句中更重要。
一个单词在文档或语料库中出现得越少(越不频繁)，在 TF-IDF 下的权重就越高。
4.2 tfidf 矢量器的工作原理
TfidfVectorizer 相当于 CountVectorizer 后跟 TfidfTransformer。
# TfidfVectorizer
corpus = ['I love bananas', 'Bananas are so amazing!', 'Bananas go so well with pancakes']
tfidf_vect = TfidfVectorizer()
corpus = tfidf_vect.fit_transform(corpus)
pd.DataFrame(corpus.toarray(), columns = tfidf_vect.get_feature_names())
我们可以看到，结果是完全一样的。因此，为了方便起见，我们将在项目中使用 TfidfVectorizer。
5.系统模型化
最后，是时候找点乐子了！
现在我们的数据已经准备好了，我们终于可以继续建模了，这实际上是建立我们的垃圾邮件过滤器，将一个给定的文本分类为垃圾邮件。
这里，我们将考虑两种建模方法:训练-测试-分割和流水线以及两种机器学习模型，或者更具体地说，集成方法:随机森林和梯度推进。
如果你是机器学习的新手，集成方法本质上是一种技术，通过它可以创建多个模型并进行组合，目标是产生比单个模型更好的预测精度。
5.1 列车-测试-分离
# Train test split
X_train, X_test, Y_train, Y_test = train_test_split(data[['body_text', 'body_len', 'punct%']], data.label, random_state = 42, test_size = 0.2)# Instantiate and fit TfidfVectorizer
tfidf_vect = TfidfVectorizer(analyzer = clean_text)
tfidf_vect_fit = tfidf_vect.fit(X_train['body_text'])# Use fitted TfidfVectorizer to transform body text in X_train and X_test
tfidf_train = tfidf_vect.transform(X_train['body_text'])
tfidf_test = tfidf_vect.transform(X_test['body_text'])# Recombine transformed body text with body_len and punct% features
X_train = pd.concat([X_train[['body_len', 'punct%']].reset_index(drop = True), pd.DataFrame(tfidf_train.toarray())], axis = 1)
X_test = pd.concat([X_test[['body_len', 'punct%']].reset_index(drop = True), pd.DataFrame(tfidf_test.toarray())], axis = 1)
5.1.1 随机森林
RandomForestClassifier 是一种集成学习方法，它利用 bagging 来构建决策树集合，然后聚合每棵树的预测来确定最终预测。
RandomForestClassifier 的关键超参数包括:
- max_depth: 每个决策树的最大深度
- n_estimators: 要构建多少个并行决策树
- 随机状态:用于再现性目的
- n_jobs: 并行运行的作业数量
在我们开始在数据上训练我们的随机森林模型之前，让我们首先使用嵌套的 for 循环构建一个手动网格搜索，以找到最佳的超参数集。
def explore_rf_params(n_est, depth):
rf = RandomForestClassifier(n_estimators = n_est, max_depth = depth, n_jobs = -1, random_state = 42)
rf_model = rf.fit(X_train, Y_train)
Y_pred = rf_model.predict(X_test)
precision, recall, fscore, support = score(Y_test, Y_pred, pos_label = 'spam', average = 'binary')
print(f"Est: {n_est} / Depth: {depth} ---- Precision: {round(precision, 3)} / Recall: {round(recall, 3)} / Accuracy: {round((Y_pred==Y_test).sum() / len(Y_pred), 3)}")
for n_est in [50, 100, 150]:
for depth in [10, 20, 30, None]:
explore_rf_params(n_est, depth)
从上面的输出，我们可以得出结论:
- 在所有情况下，精度都恒定为 1
- 随着 max_depth 的增加，查全率和查准率都有所提高，但没有一个给出最好的结果
- 在第 100 棵树之后添加更多的树几乎没有改善，所以我们将设置 n_estimators = 100。
现在我们已经有了超参数，我们可以继续使我们的模型符合数据。
# Instantiate RandomForestClassifier with optimal set of hyperparameters
rf = RandomForestClassifier(n_estimators = 100, max_depth = None, random_state = 42, n_jobs = -1)# Fit model
start = time.time()
rf_model = rf.fit(X_train, Y_train)
end = time.time()
fit_time = end - start# Predict
start = time.time()
Y_pred = rf_model.predict(X_test)
end = time.time()
pred_time = end - start# Time and prediction results
precision, recall, fscore, support = score(Y_test, Y_pred, pos_label = 'spam', average = 'binary')
print(f"Fit time: {round(fit_time, 3)} / Predict time: {round(pred_time, 3)}")
print(f"Precision: {round(precision, 3)} / Recall: {round(recall, 3)} / Accuracy: {round((Y_pred==Y_test).sum() / len(Y_pred), 3)}")
- 适合时间: 15.684
- 预测时间: 0.312
- 精度: 1.0
- 召回: 0.833
- 精度: 0.978
或者，我们也可以使用混淆矩阵来可视化二元分类的结果。
# Confusion matrix for RandomForestClassifier
matrix = confusion_matrix(Y_test, Y_pred)
sns.heatmap(matrix, annot = True, fmt = 'd')
随机森林模型的混淆矩阵
梯度增强
另一方面，GradientBoostingClassifier 也是一种集成学习方法，它采用一种称为 bagging 的迭代方法，通过关注先前迭代的错误来组合弱学习器以创建强学习器。
GradientBoostingClassifier 的关键超参数包括:
- learning_rate: 每个顺序树在最终预测上的权重
- max_depth: 每个决策树的最大深度
- n_estimators: 顺序树的数量
- 随机 _ 状态:出于再现性目的
不幸的是，梯度推进的网格搜索需要很长时间，所以我决定现在坚持使用默认的超参数。
# Instantiate GradientBoostingClassifier
gb = GradientBoostingClassifier(random_state = 42)# Fit model
start = time.time()
gb_model = gb.fit(X_train, Y_train)
end = time.time()
fit_time = end - start# Predict
start = time.time()
Y_pred = gb_model.predict(X_test)
end = time.time()
pred_time = end - start# Time and prediction results
precision, recall, fscore, support = score(Y_test, Y_pred, pos_label = 'spam', average = 'binary')
print(f"Fit time: {round(fit_time, 3)} / Predict time: {round(pred_time, 3)}")
print(f"Precision: {round(precision, 3)} / Recall: {round(recall, 3)} / Accuracy: {round((Y_pred==Y_test).sum() / len(Y_pred), 3)}")
- 拟合时间: 262.863
- 预测时间: 0.622
- 精度: 0.953
- 召回: 0.813
- 精度: 0.97
梯度推进模型的混淆矩阵
5.2 管道
管道将机器学习工作流中的多个步骤链接在一起，其中每个步骤的输出被用作下一个步骤的输入。
# Instantiate TfidfVectorizer, RandomForestClassifier and GradientBoostingClassifier
tfidf_vect = TfidfVectorizer(analyzer = clean_text)
rf = RandomForestClassifier(random_state = 42, n_jobs = -1)
gb = GradientBoostingClassifier(random_state = 42)# Make columns transformer
transformer = make_column_transformer((tfidf_vect, 'body_text'), remainder = 'passthrough')# Build two separate pipelines for RandomForestClassifier and GradientBoostingClassifier
rf_pipeline = make_pipeline(transformer, rf)
gb_pipeline = make_pipeline(transformer, gb)# Perform 5-fold cross validation and compute mean score
rf_score = cross_val_score(rf_pipeline, data[['body_text', 'body_len', 'punct%']], data.label, cv = 5, scoring = 'accuracy', n_jobs = -1)
gb_score = cross_val_score(gb_pipeline, data[['body_text', 'body_len', 'punct%']], data.label, cv = 5, scoring = 'accuracy', n_jobs = -1)
print(f"Random forest score: {round(mean(rf_score), 3)}")
print(f"Gradient boosting score: {round(mean(gb_score), 3)}")
- 随机森林得分: 0.973
- 梯度推进得分: 0.962
5.3 关于建模的总结想法
虽然在这个特定示例中，两个模型都返回了非常相似的预测结果，但重要的是要记住在其他情况下可能会出现的权衡。更具体地说，值得考虑业务环境和构建模型的总体目的。
例如，在垃圾邮件分类中，最好优化精确度，因为我们可能会处理收件箱中的一些垃圾邮件，但我们绝对不希望我们的模型将重要的邮件分类为垃圾邮件。相比之下，在欺诈检测中，更好的做法是优化召回，因为如果我们的模型未能识别出真正的威胁(假阴性)，其成本将高于识别出假威胁(假阳性)的成本。
结论
总之，在本文中，我们研究了一个端到端的自然语言处理(NLP)项目，该项目涉及构建一个能够将给定文本消息分类为垃圾邮件或垃圾邮件的二元分类器。
我们从探索数据集开始，接着是特征工程，我们创建了两个新特征: body_len 和 punct% 。然后，我们继续进行特定于 NLP 工作流的几个预处理步骤，例如:
- 将单词转换成小写字母
- 删除标点符号和停用词
- 符号化
- 词干与词汇匹配(文本规范化)
之后，我们使用执行矢量化，以便对文本进行编码，并将其转换为机器学习的特征向量。最后，我们构建了两个独立的预测模型，随机森林和梯度推进，并比较了它们各自的准确性和整体模型性能。
也就是说，非常感谢您的阅读，我期待在我的下一篇文章中见到您！
跟我来
浙公网安备 33010602011771号