如何使用 CRISP-DM 方法进行数据分析？
CRISP-DM 代表数据挖掘的跨行业标准流程。
费尔南多·巴切斯基在 Unsplash 上拍摄的照片
首先让我们把这个想法搞清楚，如果你上过一些数据科学领域的在线课程，读过一些相关的书籍，会编码，或者对如何探索/分析数据集有足够的了解，那么你就是一名数据科学家，我会把你称为数据科学家。所以当我提到数据科学家时，你知道我说的是你，而不是两年后的你。
介绍
对于数据科学家来说，以一种非常随意的方式花费大部分时间探索和清理数据是非常常见的，并且不遵循一个明确的指导方针，尽管投入时间让您的代码保持在干燥(不要重复)指导方针中是有帮助的，并且遵循一个过程以保持头脑中的大图，这就是 CRISP-DM 出现的地方。
CRISP-DM 流程可以使您的项目简化、易于理解，并为部署做好准备。
为了让 CRISP-DM 流程更容易理解，我使用了对 StackOverflow 开发者调查 2017 数据集进行的数据分析的见解。
CRISP-DM 阶段:
CRISP-DM 的阶段
CRISP-DM 阶段非常灵活，并不一定要按照所示的顺序进行。例如，在对数据建模后，您对数据的理解可能会发生变化。任何新的业务理解都可以改进您准备数据的方式，因此您可能需要采用各种策略来处理丢失的数据或您之前面临的任何其他数据问题。
这些阶段是不言自明的，但是我想在 StackOverflow 分析中展示它们的价值。
商业理解
一般来说，作为业务问题解决的一部分，我们需要一些问题的结果。我将从 StackOverflow 开发者调查 2017 数据集中回答以下 3 个问题，以更好地解释这一流程。
- 其他开发者是如何建议进入这个领域的(从事什么教育)？
- 个人的哪些因素对工资有影响？
- 帮助个人进入开发人员角色的训练营情况如何？
这些问题向数据科学家提出了一个问题陈述，他们需要利用数据来提出见解，以便业务用户可以做出决策。
数据理解
这个舞台对我的挑战最大。对我来说，正确的选择是对整个数据集进行一次整体检查，并为我勾勒出一条路径，以最大限度地发挥数据的潜力来解决公布的问题。
您可以选择这样做，或者从几个基本步骤开始学习数据:
- 数据量有多大？有多少行和多少列？
- 有多少数据丢失了？
- 有多少列包含文本、数值或分类值？(用数值以外的值转换数据需要更多时间。)
- 如果所有列包含不相关的信息，可以删除哪些列？
….以及更多类似的问题。
测量数据:数据视图
调查数据:缺失数据统计- 53 列缺失超过 50%的数据
准备数据
数据科学家一般花 80%的时间准备数据。我已经执行了以下步骤来做数据准备。
- 输入缺失值
- 数据争论
- 数据转换
我可以做更多的事情来转换数据，但是我们必须从某个地方开始，然后我们总是可以迭代。尽量遵循干的原则。
模型数据
最后，我们使用像 scikit-learn 这样的机器学习库来训练一个模型，以选择一个合适的算法，并建立一个可以使用验证集进行预测的模型，在您期望的精度内。
一旦我们达到可接受预测精度，我们就可以最终确定部署的模型。目前，我没有在这个数据集中使用预测分析进行演示。
结果
沟通是数据科学家角色中非常重要的一部分。此时，您通常会使用一些可视化或统计数据来分享您的分析结果。有时，您可能会根据结果更改建模算法或数据准备技术。让我们跳到我在 StackOverflow 开发者调查 2017 上做的 EDA 的结果。
其他开发者是如何建议打入该领域的(追求什么教育)？
调查结果
近 30%的开发人员推荐参加在线课程是成为开发人员的一种方式，只有 12.7%的开发人员认为训练营是进入 IT 领域的一种方式。
个人的哪些因素对工资有贡献？
工薪阶层的建议
已经就业的开发人员中，21%推荐参加在线课程是成为开发人员的最佳解决方案，只有 7.6%的开发人员考虑进入 IT 领域。
帮助个人进入开发人员角色的训练营是什么样的？
训练营经验持有者的就业状况
一般来说，我们认为训练营是为那些失业者和寻找开发者工作的人准备的。这些统计数据显示，46%的 Bootcamp 毕业生已经被开发人员聘用。36.5%的人在毕业后的 3 个月内找到了开发人员的工作。
部署
部署可以通过将您的方法投入生产或使用您的结果说服公司内的其他人根据结果采取行动来实现。
一旦你到了这个阶段，你可能会认为“*我的工作已经完成了，我现在需要做的就是将这段代码投入生产，然后用“*结束它。虽然，它不是那么直截了当，但也不是那么复杂。
如果您已经为自己进行了分析，那么您的工作确实已经完成，但是如果您是一名为公司/团队工作的数据科学家，您需要遵循更多的步骤来将代码部署到生产中。例如以下步骤:
- 将您的代码转换成可执行文件。py 脚本。朱庇特笔记本只是用于分析目的。只需逐行复制您的代码，并将其粘贴到一个文本文件中，然后用扩展名保存。py”。
- 例如，从代码中删除静态变量；准确性阈值、输入文件名、文件目录或路径，在运行时将这些值作为参数发送。保持你的参数列表在一个可管理的范围内。
- 简单地按照 PEP 8 风格指南在 python 脚本中添加注释形式的指令。这有助于其他开发人员理解您的代码，并在必要时做出更改。
- 您可以选择为您的函数创建单独的 python 脚本，然后将这些脚本作为库导入，就像我们导入 pandas、NumPy 等一样。
一旦您的代码准备好部署，请始终检查目标 python 环境是否安装了您的数据科学库。如果没有，您需要创建一个虚拟环境，并在部署代码之前安装所有必需的库。
如果你想让你的代码按计划运行，那么你可能需要一个像 Autosys，Cron 或者基于 Windows 的调度器这样的调度器。
结论
在本文中，我们研究了 CRISP-DM 如何在进行数据分析或训练机器学习模型时帮助维护更大的画面。来自stack overflow 2017 年开发者调查支持的见解，了解 CRISP-DM 流程的理念。
本文是 Udacity 数据科学家纳米学位项目的一部分。要了解更多关于这个分析的信息，请点击这里的链接。
这是我第一篇关于媒介的文章，希望你喜欢。感谢阅读。
如何对回归问题进行特征选择
在本文中，我将解释什么是特征选择，以及在用 Python 训练回归模型之前如何进行特征选择。
1.介绍
什么是特征选择？
特征选择是从输入 变量中选择与目标变量(我们希望预测的)最相关的子集(所有可用变量中的一部分)的过程。
目标变量这里的是指我们希望预测的变量。
对于本文，我们将假设我们只有数字输入变量和回归预测建模的数字目标。假设，我们可以很容易地估计每个输入变量和目标变量之间的关系。这种关系可以通过计算诸如相关值的度量来建立。
如果你想在交互式路线图和活跃的学习社区的支持下自学数据科学，看看这个资源:https://aigents.co/learn
2.主要的数值特征选择方法
可用于数字输入数据和数字目标变量的两种最著名的特征选择技术如下:
- 相关性(皮尔森、斯皮尔曼)
- 互信息(MI，归一化 MI)
相关性是衡量两个变量如何一起变化的指标。最广泛使用的相关性度量是皮尔逊相关性，它假设每个变量为高斯分布，并检测数值变量之间的线性关系。
这分两步完成:
- 计算每个回归变量与目标之间的相关性，即((X[:，i] — mean(X[:，I)))(y—mean _ y))/(STD(X[:，I)) STD(y))。
- 它被转换成一个 F 值，然后被转换成一个 p 值。
互信息源于信息论领域。其思想是应用信息增益(通常在决策树的构造中使用)来执行特征选择。在给定一个变量的已知值的情况下，计算两个变量和测量之间的互信息，作为一个变量的不确定性的减少。
3.数据集
我们将使用波斯顿 房屋 - 价格 数据集。该数据集包含由美国人口普查局收集的有关马萨诸塞州波士顿地区住房的信息。数据集由以下变量组成:
- CRIM——城镇人均犯罪率
- ZN——面积超过 25，000 平方英尺的住宅用地比例
- 印度河——每个城镇非零售商业用地的比例。
- CHAS——查尔斯河虚拟变量(1 如果区域边界为河流；否则为 0)
- NOX——氮氧化物浓度(百万分之一)
- RM——每个住宅的平均房间数
- 年龄——1940 年之前建造的业主自用单元的比例
- 到五个波士顿就业中心的 DIS 加权距离
- RAD——放射状公路可达性指数
- 税收—每 10，000 美元的全价值财产税税率
- pt ratio——按城镇分列的学生-教师比率
- B — 1000(Bk — 0.63)，其中 Bk 是按城镇划分的黑人比例
- LSTAT —人口中地位较低的百分比
- MEDV——以千美元为单位的自有住房的中值
4.Python 代码和工作示例
让我们加载数据集并将其分为训练集(70%)和测试集(30%)。
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import f_regression
import matplotlib.pyplot as plt
from sklearn.feature_selection import mutual_info_regression# load the data
X, y = load_boston(return_X_y=True)# split into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30, random_state=0)
我们将使用众所周知的 scikit-learn 机器库。
情况 1:使用相关性度量的特征选择
对于相关性统计，我们将使用 f_regression()函数。该功能可用于特征选择策略，如通过选择最佳类别选择前 k 个最相关的特征(最大值)。
# feature selection
f_selector = SelectKBest(score_func=f_regression, k='all')# learn relationship from training data
f_selector.fit(X_train, y_train)# transform train input data
X_train_fs = f_selector.transform(X_train)# transform test input data
X_test_fs = f_selector.transform(X_test)# Plot the scores for the features
plt.bar([i for i in range(len(f_selector.scores_))], f_selector.scores_)plt.xlabel("feature index")
plt.ylabel("F-value (transformed from the correlation values)")
plt.show()
提醒:对于关联统计情况:
- 计算每个回归变量与目标之间的相关性，即((X[:，i] — mean(X[:，I))(y—mean _ y))/(STD(X[:，I)) STD(y))。
- 它被转换成一个 F 分数，然后被转换成一个 p 值。
特征重要性图
上图显示，特性 6 和 13 比其他特性更重要。y 轴表示根据相关值估计的 F 值。
情况 2:使用互信息度量的特征选择
scikit-learn 机器学习库通过 mutual_info_regression()函数为带有数字输入和输出变量的特征选择提供了互信息的实现。
# feature selection
f_selector = SelectKBest(score_func=mutual_info_regression, k='all')# learn relationship from training data
f_selector.fit(X_train, y_train)# transform train input data
X_train_fs = f_selector.transform(X_train)# transform test input data
X_test_fs = f_selector.transform(X_test)# Plot the scores for the features
plt.bar([i for i in range(len(f_selector.scores_))], f_selector.scores_)plt.xlabel("feature index")
plt.ylabel("Estimated MI value")
plt.show()
特征重要性图
y 轴表示每个特征和目标变量之间的估计互信息。与相关性特征选择方法相比，我们可以清楚地看到更多的特征被评分为相关。这可能是因为数据集中可能存在统计噪声。
5.结论
在这篇文章中，我提供了两种方法来执行特性选择。特征选择是选择与目标变量最相关的输入变量子集(所有可用变量中的一部分)的程序。目标变量这里的是指我们希望预测的变量。
使用相关性度量或者相互 信息度量，我们可以很容易地估计每个输入变量和目标变量之间的关系。
相关性 vs 互 **信息:**与相关性特征选择方法相比，我们可以清楚地看到更多的特征被评分为相关。这可能是因为数据集中可能存在统计噪声。
您可能还喜欢:
[## LSTM 时间序列预测:使用 LSTM 模型预测股票价格
在这篇文章中，我将向你展示如何使用预测 LSTM 模型来预测股票价格
towardsdatascience.com](/lstm-time-series-forecasting-predicting-stock-prices-using-an-lstm-model-6223e9644a2f) [## 时间序列预测:使用 ARIMA 模型预测股票价格
在这篇文章中，我将向你展示如何使用预测 ARIMA 模型来预测特斯拉的股票价格
towardsdatascience.com](/time-series-forecasting-predicting-stock-prices-using-an-arima-model-2e3b3080bd70)
敬请关注并支持这一努力
如果你喜欢这篇文章，并且觉得它有用，那么关注我就可以看到我所有的新帖子。
有问题吗？把它们作为评论贴出来，我会尽快回复。
最新帖子
最有用的免费书籍和在线课程，适合想了解更多数据科学知识的人。
medium.com](https://medium.com/@seralouk/the-best-free-data-science-resources-free-books-online-courses-9c4a2df194e5) [## 用新冠肺炎假设的例子解释 ROC 曲线:二分类和多分类…
在这篇文章中，我清楚地解释了什么是 ROC 曲线以及如何阅读它。我用一个新冠肺炎的例子来说明我的观点，我…
towardsdatascience.com](/roc-curve-explained-using-a-covid-19-hypothetical-example-binary-multi-class-classification-bab188ea869c) [## 支持向量机(SVM)解释清楚:分类问题的 python 教程…
在这篇文章中，我解释了支持向量机的核心，为什么以及如何使用它们。此外，我还展示了如何绘制支持…
towardsdatascience.com](/support-vector-machines-svm-clearly-explained-a-python-tutorial-for-classification-problems-29c539f3ad8) [## PCA 清楚地解释了——如何、何时、为什么使用它以及特性的重要性:Python 指南
在这篇文章中，我解释了什么是 PCA，何时以及为什么使用它，以及如何使用 scikit-learn 在 Python 中实现它。还有…
towardsdatascience.com](/pca-clearly-explained-how-when-why-to-use-it-and-feature-importance-a-guide-in-python-7c274582c37e) [## 关于 Python 中的最小-最大规范化，您需要知道的一切
在这篇文章中，我将解释什么是最小-最大缩放，什么时候使用它，以及如何使用 scikit 在 Python 中实现它
towardsdatascience.com](/everything-you-need-to-know-about-min-max-normalization-in-python-b79592732b79) [## Scikit-Learn 的标准定标器如何工作
在这篇文章中，我将解释为什么以及如何使用 scikit-learn 应用标准化
towardsdatascience.com](/how-and-why-to-standardize-your-data-996926c2c832)
和我联系
- LinkedIn:【https://www.linkedin.com/in/serafeim-loukas/
- https://www.researchgate.net/profile/Serafeim_Loukas研究之门:
- https://people.epfl.ch/serafeim.loukasEPFL简介:
- 堆栈 溢出:https://stackoverflow.com/users/5025009/seralouk
如何满怀信心地执行线性回归
它的工作原理和失败之处
由 Unsplash 上 Greg Rakozy 拍摄的照片
线性回归可能是建模关系最广泛使用的方法之一。它的主要吸引力在于它很容易向非技术读者解释，并且假设关系是线性的。
在这篇文章中，我们将解释线性回归的理论和假设，并实现产生类似于scipy . stats . Lin regression结果的代码。
代码用 Python 3.x 编写，整个工作流程可以在这里找到:https://github . com/NadimKawwa/Statistics/blob/master/linear _ regression . ipynb
假设
- 弱外生性:我们假设预测变量是无误差的，例如没有现场测量误差。
- 线性:响应变量的平均值是参数和预测变量的线性组合。
- 同方差:响应变量的不同值在其误差中具有相同的方差(方差齐性)。
- 误差的独立性:响应变量的误差彼此不相关。
- 缺乏完美的多重共线性:对于最小二乘估计方法，设计矩阵 X 必须具有满秩，否则可能意味着一个预测变量被给出两次。
最小二乘法
理论
在实践中，有许多问题，其中一组配对数据给出回归是线性的指示，其中我们不知道所考虑的随机变量的联合分布。
最小二乘法的法是一种近似线性关系的曲线拟合方法。
请看下表，该表显示了随机抽取的 10 名学生的考试成绩和学习时间:
在下图中，我们展示了学习时间与考试分数的分散情况:
我们得到的印象是，直线提供了相当好的拟合，因此估计的回归线给出如下:
假设我们拟合了一条任意的线，这条线很好地估计了线性关系。我们如何确定拟合优度？设ei表示一个点到估计回归线的垂直偏差。因此，我们希望最小化关于 α 和 β 的量 q:
我们不详细讨论 q 相对于α和β的部分微分，而是直接跳到解，并引入以下符号来简化未来的计算:
给定样本数据(xi，易)，最小二乘系数α和β为:
履行
在下面的代码中，我们实现了这个简单的线性回归。我们首先定义一个助手函数 getPairStats 来计算 Sxx、Syy 和 Sxy:
实施线性回归现在变得简单明了:
为了更深入地了解我们正在做的事情，请考虑下面的图表，其中显示了拟合直线和垂直偏差的结果。
假设检验
理论
在正态回归分析中，假设对于每个固定的 Xi，相应的随机变量 Yi 的条件密度是正态密度:
这样，α、β和σ对于每个 I 都是相同的。给定配对数据的随机样本，正态回归分析涉及σ和回归系数α和β的估计，以及关于这些参数的假设检验。
σ的最大似然估计由下式给出:
更多的时候，我们感兴趣的是测试斜率β。我们注意到β hat 具有正态分布，在正态回归分析的假设下，具有(N2)自由度的 t 分布的随机变量的值计算如下:
为了建立参数β的(1-α)置信区间:
履行
现在让我们测试以下关于学习时间与分数的假设:
- H0: β=3
- H1: β>3
- 设置显著性水平α=0.01
下面的函数基于上一节中的配对回归函数，如果我们没有拒绝 H0，则返回 False，否则返回 True。
参考相同的数据，我们可以为β构建 95%的置信区间:
在截距保持不变的情况下，我们的回归看起来如何？下面的图提供了一个可视化。
正态相关分析
理论
样本相关系数表示为 r，衡量两组数据 X 和 y 之间的线性关系强度。当 r=0 时，随机变量不相关。该系数计算如下:
使用辅助函数 getPairStats，计算 r 非常简单:
陷阱
线性回归的局限性在假设中是显而易见的。此外，我们必须记住，相关性并不意味着必然的因果关系。
Anscombe 的四重奏是 11 个数据点(x，y ),它们被设计成具有几乎相同的均值、标准差和相关性。结果是相同的回归线，证明了在绘制图形之前绘制数据的必要性以及异常值的影响。
另一个考虑因素是季节性，特别是对于时间序列图。对所有时间跨度使用一个斜率系数可能没有意义。
多元线性回归
理论
在实际应用中，我们将面临许多使用多个变量来逼近目标结果的情况。在这一节中，我们将简单的线性回归推广到多元线性模型。
我们可以使用矩阵符号来求解多元线性回归。设 X 是一个由给定值组成的(n，k+1)矩阵，第一列附加了常数项。y 是由 y 的观察值组成的(n，1)矩阵，即列向量。B 是由回归系数的最小二乘估计组成的(k+1，1)矩阵。
在矩阵格式中，X、Y 和 B 写为:
多元回归系数的最小二乘估计由下式给出:
履行
考虑使用卧室数量和浴室数量来预测房屋价格的尝试:
为了节省以后的计算时间，我们定义了一个辅助函数 calculate (X.T X)-。在下一节中，这个术语将被证明是重要的:
上面的等式在下面的紧凑函数中解释:
多重假设检验
对于多个系数，需要针对无效假设测试每个系数。在上面的例子中，系数 B1=15，314 意味着每间卧室在要价上增加了大约 15，000 美元。
具有(n-k-1)个自由度测试统计量由下式给出:
使得 c_ii 是矩阵(X.T X)的第 I 行和第 I 列；
履行
假设我们希望测试以下假设:
- H0: B1=9500
- H1: B1>9500
- 设置显著性水平α=0.05
在函数中实现它:
我们得出的结论是，平均每间卧室会给房子的要价增加 9500 美元以上。
结论
线性回归是近似关系的有用工具，广泛应用于所有科学领域。它的简单和易于解释使它成为向技术观众和外行人传达结果的首选。
当然还有更多回归方法，如 KNN 回归和随机森林回归。
参考
约翰·e·弗罗因德，数理统计及其应用，第 8 版
在统计学中，简单线性回归是只有一个解释变量的线性回归模型。那就是，它…
en.wikipedia.org](https://en.wikipedia.org/wiki/Simple_linear_regression) [## 线性回归
在统计学中，线性回归是一种建模标量响应(或变量)之间关系的线性方法
en.wikipedia.org](https://en.wikipedia.org/wiki/Linear_regression)
如何在 Python 中执行金融投资组合的场景分析
蒙特卡罗模拟在金融投资组合情景分析中的应用
金融投资者知道没有人能预测未来，但他们也知道他们必须至少对未来的可能性有一个概念。这就是为什么情景分析是投资者工具箱中非常强大的工具。
情况分析
情景分析是一门学科，它试图给出与一种现象相关的未来可能发生的情景的概率观点。
在上一篇文章中，我已经向您展示了如何使用遗传算法在 R 中执行投资组合优化。虽然投资组合优化是一门科学，但情景分析几乎就像一门艺术。它通常从一些假设开始，然后使用蒙特卡罗技术模拟许多未来情景。模拟场景的数量越多，精确度越高。最后，对所有仿真结果进行了分析。例如，金融投资组合的典型情景分析可以与风险相关(例如，我们的投资组合在 30 天内损失 3%的概率是多少)。
在本文中，我将向您展示如何将情景分析应用于金融投资组合。对于这个例子，我们将使用 2010 年 1 月 1 日至 2019 年 1 2 月 31 日的每日历史数据，模拟由微软(50%)、苹果(20%)和谷歌(30%)股票组成的投资组合。我们将以比过去更悲观的方式修正他们的平均回报率，并计算我们投资组合的累积预期回报率、置信区间和预期夏普比率。
一切都将在 Python 中完成。你可以在这里获得 GitHub 上的完整笔记本:https://GitHub . com/gianlucamalato/machine learning/blob/master/Portfolio _ scenario _ analysis . ipynb
数据收集
首先，我们需要安装yfinance库。它允许我们直接从笔记本上下载股票价格。
!pip install yfinance
然后我们可以导入一些有用的库:
import yfinance
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
对于每只股票，我们要计算从第 t 天到第 t+1 天的收盘价 P 的日收益，定义为
幸运的是，Python 系列提供了有用的 pct_change 方法，为我们计算这个公式。
让我们来定义投资组合的组成和用每只股票的日收益填充熊猫数据框的循环。
portfolio_composition = [('MSFT',0.5),('AAPL',0.2),('GOOG',0.3)]
returns = pd.DataFrame({})for t in portfolio_composition:
name = t[0]
ticker = yfinance.Ticker(name)
data = ticker.history(interval="1d",
start="2010-01-01",end="2019-12-31")
data['return_%s' % (name)] = data['Close'].pct_change(1) returns = returns.join(data[['return_%s' % (name)]],
how="outer").dropna()
returns数据帧如下所示:
现在我们准备模拟我们的数据。
单一股票的蒙特卡罗模拟
如果我们想在未来模拟 m 天，我们只需要:
- 以一只股票的原始收益时间序列为例
- 选择替换的 m 值，随机均匀取值
就是这样。它与 bootstrap 非常相似，bootstrap 是一种重采样技术。这种方法假设未来收益是对过去收益的随机重采样。这是一个很强的近似值，但它可以是一个很好的起点。
这种模拟可以通过下面函数中的一行代码轻松完成:
def simulate_returns(historical_returns,forecast_days):
return historical_returns.sample(n = forecast_days,
replace = True).reset_index(drop = True)
如果我们尝试模拟 1000 天，我们会得到:
simulate_returns(returns['return_AAPL'],1000)
现在让我们为模拟投资组合创建必要的函数。
投资组合的蒙特卡罗模拟
投资组合是收益和权重的组合。给定第 i- 只股票的收益 R ᵢ，给定投资组合中每只股票的权重 w ᵢ(所有权重总和必须为 1)，投资组合收益 R 可以表示为:
这是股票收益的加权和。
这是从我们之前创建的returns数据帧开始执行所有计算的函数:
def simulate_portfolio(historical_returns,
composition,
forecast_days):
result = 0
for t in composition:
name,weight = t[0],t[1]
s = simulate_returns(historical_returns['return_%s' % (name)],
forecast_days)
result = result + s * weight
return(result)
让我们看看如果我们模拟 10 天的投资组合会发生什么:
simulate_portfolio(returns,portfolio_composition,10)
对于投资组合模拟来说，这可能已经足够了，但是我们还需要更多，那就是假设分析。
假设分析
如果我们像之前那样进行投资组合模拟，我们只是说未来收益是过去收益的随机样本。我们已经知道这并不完全正确。此外，也许我们正在进行情景分析，因为我们想知道如果某些条件将会发生什么。比如，如果每只股票的日均收益低于其历史价值，会发生什么？
历史平均回报率为:
让我们试着模拟一下，如果 MSFT 的平均回报率下降-0.0001，AAPL 下降-0.001，谷歌下降-0.0005，会发生什么。我们必须从每只股票中减去这些数量，然后用修改后的新数据模拟未来的投资组合。
我们将把这些修正直接添加到portfolio_composition列表中(它们是每个元组的第三个组件):
portfolio_composition = [
('MSFT', 0.5,-0.0001),
('AAPL', 0.2,-0.001),
('GOOG', 0.3,-0.0005)
]
然后我们可以重新定义所有先前定义的函数。
这是模拟修改股票的功能:
def simulate_modified_returns(
historical_returns,
forecast_days,
correct_mean_by): h = historical_returns.copy() new_series = h + correct_mean_by return new_series.sample(n=forecast_days,
replace = True).reset_index(drop=True)
这是模拟修改后的投资组合的函数:
def simulate_modified_portfolio(
historical_returns,
composition,
forecast_days):
result = 0
for t in composition:
name,weight,correction = t[0],t[1],t[2]
s = simulate_modified_returns(
historical_returns['return_%s' % (name)],
forecast_days,correction
)
result = result + s * weight
return(result)
最后，我们可以定义一个多次执行投资组合模拟的函数，生成许多可能的场景:
def simulation(
historical_returns,
composition,
forecast_days,
n_iterations):
simulated_portfolios = None for i in range(n_iterations):
sim = simulate_modified_portfolio(
historical_returns,
composition,
forecast_days
) sim_port = pd.DataFrame({'returns_%d' % (i) : sim}) if simulated_portfolios is None:
simulated_portfolios = sim_port
else:
simulated_portfolios = simulated_portfolios.join(sim_port)
return simulated_portfolios
现在我们准备开始我们的模拟和分析结果。
模拟和结果
让我们模拟未来 20 天，计算 200 个不同场景的统计数据。
forecast_days = 20
n_iterations = 200
我们现在可以运行模拟:
simulated_portfolios = simulation(returns,
portfolio_composition,forecast_days,n_iterations)
如果迭代次数很多，此功能可能需要几秒钟甚至几分钟。
这是结果:
每一列是一个模拟投资组合的场景，每一行是未来的一天。
以投资组合的每日收益为例，我们可以用复利公式计算出 N 天后的收益:
由于回报是非常小的数字，我们可以将该表达式近似为:
即 N 天后的收益是 N 天的收益之和。
我们现在可以从这个数据集计算一些可观测量。
未来回报的置信区间
情景分析可以用作风险管理工具。为此，我们可能要计算未来累积回报的第 5 个和第 95 个百分位数。前者告诉你，我们的投资组合有 5%的机会跑输这个价值，后者告诉你，你的投资组合有 5%的机会跑赢这个价值。我们还想了解投资组合的平均表现。
下面是计算这三条曲线的代码。
percentile_5th = simulated_portfolios.cumsum().apply(lambda x : np.percentile(x,5),axis=1)percentile_95th = simulated_portfolios.cumsum().apply(lambda x : np.percentile(x,95),axis=1)average_port = simulated_portfolios.cumsum().apply(lambda x : np.mean(x),axis=1)
情节是这样的。
波段是百分位数，实线是平均投资组合。如你所见，20 天后，我们的投资组合有 5%的可能性会损失 5.3%(低波段)，有 5%的可能性我们的投资组合回报会高于 8.3%(高波段)。平均而言，我们预计我们的投资组合有 1%的回报率(实线)。
达到目标回报的概率
我们可以进行的另一种分析是，作为未来一天的函数，我们的投资组合跑赢目标回报的概率。
由于概率是一个可观测的值，我们也想计算它的标准误差。
如果我们有一个样本概率 p (即肯定事件的数量除以场景的数量 N )，其标准误差的估计值为:
我们可以使用每天计算的这个值，在图表中显示误差线。
假设我们有一个 2%的目标。达到这一目标的概率计算如下:
target_return = 0.02target_prob_port = simulated_portfolios.cumsum().apply(
lambda x : np.mean(x > target_return)
,axis=1)
误差线的大小用标准误差公式计算:
err_bars = np.sqrt(
target_prob_port * (1-target_prob_port) / n_iterations
)
最后，我们可以绘制结果:
正如你所看到的，超额完成我们的目标回报的可能性随着时间的推移而增加(这显然是正确的，因为我们的投资组合有正的平均回报)。20 天后，我们的投资组合将以 38.0 +/- 3.4%的概率跑赢 2%的目标。
夏普比率的期望值和直方图
最后，我们可以计算一些与夏普比率相关的统计量。这是一个非常受欢迎的投资组合绩效指标，对于本例，我们可以计算投资组合的夏普比率回报率 R 如下:
其中 E(x) 是期望值， Var(x) 是方差。
我们的 200 个投资组合场景中的每一个都有自己的夏普比率，所以我们可以计算出每一个的夏普比率。然后我们可以绘制直方图并计算平均值。
sharpe_indices = simulated_portfolios.apply(
lambda x : np.mean(x)/np.std(x)
)
直方图为:
平均值为:
结论
在本文中，我向您展示了如何用 Python 对金融投资组合进行简单的场景分析。这种方法可以适用于许多问题和情景(例如，波动性增加、黑天鹅、某些行业的危机)，以评估投资组合未来可能的风险及其成长能力。
这个工具可以很容易地与投资组合优化混合，以评估金融资产配置的完整分析。
参考
[1]吉安卢卡·马拉托。利用遗传算法进行 R 中的投资组合优化。交易科学家。https://medium . com/the-trading-scientist/portfolio-optimization-in-r-using-a-genetic-algorithm-8726 EC 985 b 6 f
[2]吉安卢卡·马拉托。自举。任何数据科学家的瑞士军刀。数据科学记者。https://medium . com/data-science-reporter/the-bootstrap-the-Swiss-army-knife-of-any-data-scientist-acd6e 592 be 13
[3] 二项分布页。维基百科。https://en.wikipedia.org/wiki/Binomial_distribution
[4] 夏普比率页。维基百科。https://en.wikipedia.org/wiki/Sharpe_ratio
如何利用 MAFFT 对 2019-nCoV 执行序列对齐
截至 2020 年 1 月 26 日，2019-nCoV 已经在中国武汉造成 76 人死亡。作为一种针对人类呼吸系统的冠状病毒，2019-nCoV 具有很高的传染性，尤其是在潮湿和寒冷的季节。
DNA，图片来自 Pixabay
呼吸系统相关的病原体可以随着体液从喷嚏中高速射出。它们可以通过多种方式感染人类，最常见的是通过接触嘴、鼻子和眼睛。为避免感染，建议避免户外活动，尤其是在人群密集的地方。经常消毒双手，不要用手揉眼睛也很重要。
人们开玩笑说，他们现在只要躺在家里的沙发上就可以为社会做贡献。我在农历新年期间的所有会议计划现在都取消了。所以我决定分享一个教程，如何获取 2019-nCoV 的基因序列数据，并用 MAFFT 对其进行序列比对。我希望这篇文章提高了人们对生物信息学研究的兴趣，并有助于我们对抗下一场流行病。
什么是序列比对和 MAFFT？
序列比对是一种排列 DNA、RNA 或蛋白质以识别相似区域的方法，这可能揭示序列之间的功能、结构或进化关系。最近的一份出版物提出，借助于 MAFFT 的序列比对，蛇可以跨物种传播给人类。
MAFFT(MmultipleAalignment usingFastFourierTtransform)是 2002 年发表的一个多序列比对程序。它可用于 RNA 序列的序列比对。冠状病毒是例如具有单链 RNA 的病毒，该单链 RNA 被包裹在来源于宿主细胞膜的外壳中。关于 MAFFT 算法的细节可以在找到。
从哪里获取 RNA 序列数据？
2019-nCoV 的最新更新可以在 NGDC (中国国家基因组数据中心)上找到。在本教程中，我们将分析在 NCBI(国家生物技术信息中心)数据库内发现的 2019-nCoV 病毒和 SARS-CoV 病毒。SARS-CoV，众所周知的 SARS(严重急性呼吸综合征),在 2020 年左右在 17 个报告的国家中导致 774 人死亡。
我有一份拷贝，并将数据粘贴到一个以病毒名称命名的文件中。它们应该类似于上面的内容，一个索引号后跟一批 10 个代码，每行 60 个代码，用空格分隔。我已经上传了这个分析的相关文件，并在本文末尾附上了链接。
如何用 MAFFT 对 2019-nCoV 进行序列比对？
首先，我们需要安装 MAFFT。我们可以用下面的命令通过 Anaconda 安装它。不同操作系统的手动安装可以在maftt 官网找到。
conda install mafft
MAFFT 非常容易使用，但是它以一种特殊的格式处理数据。我们将需要对我们获得的数据进行预处理，以便它可以通过 MAFFT 进行校准。下面是执行此操作的 Python 脚本:
import sys
import re
output = ""
for filename in sys.argv[1:]:
infile = open(filename)
data = infile.read()
data = " ".join(re.split("[^atcg\n]", data))
data = data.replace(" ", "")
output = output + ">" + filename + "\n" + data + "\n"
print(output)
outfile = open('SEQUENCES.txt', 'w+')
outfile.write(output)
我们可以将上面的 Python 代码保存到一个名为“preprocess.py”的文件中，与我的病毒 RNA 数据放在同一个文件夹中。然后我们可以在文件夹中运行下面的 bash 命令来预处理数据。
python3 preprocess.py 2019-nCoV_HKU-SZ-002a_2020 icSARS-C7-MA
名为“SEQUENCES.txt”的输出文件现在应该如下所示。由于病毒名称附加在文件的前面，空格和索引号也被去掉。
现在，我们可以通过以下步骤在我们的终端下使用 MAFFT 执行序列比对:
- 定位到工作文件夹。
- 在终端内呼叫“mafft”。
- 对于输入文件，输入“SEQUENCES.txt”。
- 对于输出文件，输入“output.txt”。
- 为“Clustal 格式”选择“1”作为输出格式。
- 选择“1”作为“自动”策略。
- 为附加参数保留空白。
在我们按下回车键后，我们只需要等待 MAFFT 来排列我们的 RNA 代码。成品应该看起来像下面的东西。“-”用于移动代码，下面的“*”表示类似的顺序。
恭喜你，你已经学会了如何使用 MAFFT 进行序列比对！现在你可以玩基因代码，并利用你喜欢的排列信息！
附录(相关文件的链接)
此时您不能执行该操作。您已使用另一个标签页或窗口登录。您已在另一个选项卡中注销，或者…
github.com](https://github.com/shenhuang/shenhuang.github.io/tree/master/2019-nCoV)
作为开发人员、数据科学家等，帮助武汉抗击致命疾病:
https://github.com/wuhan2020/wuhan2020
如何通过 5 个步骤执行威胁建模和安全分析
彼得·拉格森在 Unsplash 上的照片
想学习如何执行威胁建模吗？
那么，你来对地方了。
但在此之前，让我们快速讨论一下执行威胁建模和安全分析的重要性。
如今，几乎所有的软件系统都面临着各种各样的威胁，随着技术的成熟，网络攻击的数量也在不断上升。根据的一份报告，2018 年第二季度，利用软件漏洞的恶意软件增长了 151%。
安全漏洞可能是由内部或外部实体造成的，它们可能会带来灾难性的后果。这些攻击可能会泄漏您组织的敏感数据或完全禁用您的系统，甚至可能导致数据完全丢失。
您如何保护您的数据不被窃取或防止恶意攻击您的设备？
一种开始的方法是执行威胁建模，这是一个帮助您分析您的环境、识别潜在的漏洞和威胁，并创建适当的安全需求来应对这些威胁的过程。
对于您的设备，什么是合适的安全级别？威胁建模如何帮助您实现这一级别？
为了设计安全性，建议开发人员和制造商分析操作环境，以确定每台设备可能受到的攻击，然后记录下来。
理解和记录安全需求的过程被称为威胁建模和安全分析(TMSA)。
但是，执行威胁建模和安全分析如何帮助您保护您的设备免受网络安全攻击呢？
它可以帮助您分析您的设备并了解:
- 您的安全性需要有多强？
- 您应该采取哪些预防措施来避免安全问题？
- 哪些潜在威胁会影响您的设备？
威胁建模和安全分析(TMSA)强调了在实施安全措施来保护您的产品或设备时应该考虑的关键问题和挑战。
它会提示您考虑一些关键问题，例如:
- 您的设备面临哪些潜在威胁？
- 这些威胁有多严重？
- 您的设备符合安全标准吗？
- 有哪些潜在的漏洞会使您的设备面临安全漏洞的风险？
- 您可以实施什么对策来保护您的设备？
执行威胁建模的步骤
下面是一个分步过程，它将帮助您了解如何执行威胁建模和安全分析来确定您的安全需求。
步骤 1:确定用例、要保护的资产和外部实体
执行威胁建模的第一步是确定一个用例，即作为您的安全评估主题的系统或设备。通过这样做，你将会知道什么设备或系统需要进一步分析。
由于攻击者可能会以您的设备为目标来窃取重要数据或恶意操作，因此您需要识别包含敏感信息或最有可能受到攻击的资产。
例如，如果您有一个智能扬声器，那么您可能希望保护以下资产:
- 登录凭证
- 网络通信
- 固件
- 事件日志
- 证书和唯一密钥
- 系统配置(保护您的 IP 地址)
- 设备资源(如扬声器、麦克风阵列、电池、存储、调试接口、网络带宽和计算能力)
您的设备中可能有许多不同的资产，但重要的是，您要专注于保护保存有价值数据且对您的组织和客户至关重要的资产。
此外，为了识别和了解可能影响您设备的潜在威胁，您需要确定与设备交互的外部实体和用户。
这可能包括合法用户，如虚拟系统管理员或设备所有者。但是它还应该扩展到识别试图访问设备的潜在对手或攻击者。
一旦确定了这些，就该进入执行威胁建模的下一步了。
步骤 2:确定信任区域、潜在对手和威胁
在执行威胁建模的这一步中，您必须确定信任区域和相应的入口-出口点。通过使用这些信息，您可以开发带有权限边界的数据流图，这将帮助您定义输入数据验证、用户身份验证和错误处理的方法。
此外，您需要创建一个基于对手的威胁模型，以帮助您识别可能试图利用或攻击您设备的潜在对手和攻击者。
通常，基于对手的威胁模型有四类攻击者:
- **网络攻击者:**这种类型的攻击者可能会进行中间人攻击等网络攻击，攻击者拦截双方的通信。
- **恶意内部攻击者:**这些攻击者可能是您的员工、第三方供应商或任何能够访问您的设备或网络的个人。
- **远程软件攻击者:**大多数攻击者都属于这一类，他们试图通过引入恶意脚本/代码或病毒来破坏安全软件，从而窃取数据或控制设备/网络。
- **高级硬件攻击者:**这些攻击者通常拥有高级资源，需要物理接触设备。他们经常在专业设备的帮助下部署复杂的攻击，如显微镜探测或离子束光刻。
至此，您应该已经确定了需要保护的内容，以及哪些潜在的对手可能会导致安全漏洞。
接下来，您应该识别潜在的漏洞，包括软件、物理设备、开发生命周期和通信，它们可能作为进入您设备的入口点，并允许攻击者进入您的系统。
这些漏洞包括哪些？
这些漏洞可能包括过多的用户访问权限、薄弱的密码策略、缺乏 Web 应用程序防火墙(WAF)、不可靠的身份验证、不安全的加密存储、缺乏安全指南或安全错误配置。
一旦确定了潜在的漏洞，就可以针对每个入口点实现一个威胁模型来确定安全威胁。
但是，如何设计合适的安全级别来保护您的设备免受这些威胁呢？
在识别潜在的安全威胁后，您需要考虑评估每个威胁或攻击的严重性，并适当地分配您的资源。
您可以使用通用漏洞评分系统(CVSS)来评估威胁的影响。它使用 0 到 10 之间的分数来帮助您了解攻击会如何影响您的设备。
例如，如果威胁的 CVSS 分数是 9，那么您应该将您的资源和注意力集中在它上面，因为它的影响将是严重的。
通过这样做，您将能够在您的设备中建立适当的安全级别。
步骤 3:确定应对潜在威胁的高级安全目标
在如何执行威胁建模的这一步中，您必须建立安全目标，重点维护以下安全元素:
- 机密
- 有效性
- 完整
- 安全开发生命周期
- 真实性
- 不可否认性
攻击的类型决定了这些安全元素的风险。
例如，您可以确定篡改攻击可能会影响设备的完整性，而欺骗攻击可能会影响设备的真实性。
一旦您评估了潜在威胁及其严重性，您将能够确定需要采用什么对策来应对这些威胁，以及如何适当地应对它们。
步骤 4:明确定义每个安全目标的安全需求
由于每个威胁对高级安全目标构成不同的风险，您需要分析并创建具体的、可操作的安全需求，以直接应对这些威胁。
例如，为了保护身份，您应该:
- 维护角色、可信的通信渠道和授权
- 实现最低特权用户访问
- 设置故障阈值限制
- 安全远程管理
步骤 5:创建一个文档来存储所有相关信息
一旦收集了为系统设置安全要求所需的所有必要信息，就可以创建一个威胁建模文档来准确存储这些信息。
你应该在这份文件中包括什么？
该文档应包括单独的表格，列出您需要保护的资产、潜在的对手和威胁、您需要采取的对策以及安全要求。
它应该是结构良好的，并且具有清晰简明的信息，以帮助您了解攻击的潜在严重性以及如何应对每种威胁。
维护良好的文档可以帮助您高效地执行威胁建模和安全分析(TMSA)。
本指南中关于如何执行威胁建模的关键要点
既然您对威胁建模以及如何执行威胁建模有了更多的了解，那么就从 TMSA 文档开始吧。请记住，您需要根据安全需求识别潜在的漏洞，这将有助于保护您的系统免受攻击者和威胁。
关于如何执行威胁建模，您还有其他问题吗？请联系我们的安全专家。
关于作者:
Steve Kosten 是 Cypress Data Defense 的首席安全顾问，也是“Java/JEE 中的 SANS DEV541 安全编码:开发可防御应用程序”课程的讲师。
在预算有限的情况下，如何为深度学习 PC 挑选零件？
介绍
我想我不需要提及这样一个事实，即像大多数人一样，我们研究人员，或者更准确地说，博士生在考虑计算机设备时是有预算的。我不能代表其他国家，但在克罗地亚，作为一名助教，你可以期待一台像样的中档笔记本电脑。对于大多数人来说，这很好，因为我认识的大多数博士生都在实验室工作或进行实地实验，对他们来说，一台能够运行 excel、R 和/或 Python 的基本统计脚本、一些 GIS 软件或 AutoCAD 的像样的笔记本电脑就足够了。
在相当长的一段时间里，我认为一台像样的笔记本电脑将非常适合我的水文学和水文模型相关的研究。这真的很棒，一切都运行得又快又好(多亏了固态硬盘和 16g 内存)。随着我开始处理大量数据，尤其是格式不太好的数据(在我的另一篇文章中找到如何解决这个问题)。在我的导师和一位也在类似职位工作的朋友的建议下，我越来越开始认为我需要学习编程，以缩短与数据格式化、复制等相关的无聊任务。我决定给 Python 一个机会。
瞬间，我兴奋地发现这是一门多么棒的编程语言，它让我可以轻松完成一些任务，而我通常会在 excel 中浪费 3-4 个小时来完成这些任务。不要误会我的意思，这不是对 excel 的指责，无论如何它对一些快速可视化，数据管理或作为一个简单的数据库来说都是很棒的。但是越来越多的时候，我的任务中，一个写得好、想得好的 Python 脚本只是赢得了游戏，让生活变得更容易。
让我们回到这个故事的主题。当你在网上消费 Python 和 Data Sconce 相关的内容时，你迟早会偶然发现“机器学习”这个术语，因为 Python 在这类任务中很受欢迎。这正是发生在我身上的事情。很快我就迷上了，并开始对这个话题进行更多的研究。
很快，我发现自己注册了 Udacity 课程“用 Python Nanodegree 进行人工智能编程”，在封锁期间，我可以免费使用 Udacity 的某些课程 30 天。课程的最终目标是建立一个花的图像分类器。简而言之，您得到了一个输入图像，代码将它分类到一个定义的标签中。我花了大约一个半月的时间通过了这门课程。
当你开始机器学习任务，特别是深度学习时，你经常会发现一些“绿色果汁”(NVIDIA GPU😉)可以让你的中端笔记本电脑或个人电脑运行得更快。为什么会这样呢？答案是，CUDA 核心。为什么它们如此重要，在此阅读 伟大文章 ！因此，在预算有限的情况下，我开始在电脑爱好者论坛和网站上查找二手硬件的二手零件。
我不会提供任何测试结果，这更多的是一个建议类型的文章，从我的角度和多年的经验购买二手零件的论坛和不同的网站。我将试着解释哪些零件可以买二手货，以节省一些现金，或用同样的钱获得更好的性能，而不冒不必要的风险。
中央处理器
许多人认为“中央处理器”或简称 CPU 是计算机的心脏。当你一起搜索术语“CPU”和“深度学习”时，最常见的问题是“CPU 对深度学习重要吗？”。这是一个棘手的问题，我找到的最好的答案可能是科林·卡萨迪在 Quora 上的回答，“这和游戏一样重要”。由于 CPU 为 GPU 做数据准备的工作，它必须足够快，以避免所选 GPU 出现瓶颈。CPU 可以被认为是一辆快车，它可以非常快地从主存中获取数据，但它的带宽很低，因此它不能一次处理大量数据。
我发现必须考虑的事情有:a) **内核数量(和时钟速度)**和 b) 价格(当你预算紧张时很重要)。
自 2017 年锐龙问世以来，许多人认为它比英特尔更有价值。或许这是真的。尤其是在工作负载方面，锐龙远远超过英特尔。英特尔唯一能大放异彩的是游戏。
我试图找到二手零件之间的最佳交易。我不是在寻找英特尔或 AMD，只是最好的性价比。我发现一款英特尔 i5 8400 非常划算，这是一款 6 核 6 线程 CPU，基础时钟为 2.8 GHz，提升为 4.0 GHz。当然，i7 或锐龙肯定会更好，但当时没有好的交易。
我强烈建议你去当地的二手电脑网站看看，比如易趣或者亚马逊，因为 CPU 很少会坏。就物理损坏而言，英特尔可能更难损坏，因为触针在主板上，而 AMD 的触针在 CPU 上。
一如既往，购买二手设备时，最好的选择是亲自移交，以避免欺诈或物理损坏的零件。
主板或 MBO
当你决定哪种 CPU 最适合你的需求时，是时候为它选择合适的 MBO 了。由于我不需要支持多 GPU 或许多硬盘驱动器，一个更基本的板将做这项工作。自从我去了英特尔，他们提供了几种不同的芯片组 H、B、Q 和 Z 。h 和 B 芯片组是基本的，而 Z 提供更多的升级选项和功能，是为发烧友，超频和游戏玩家。我在我的城市附近找不到一个好的二手交易，所以我去当地商店买了一个来自 Asrock board 的 H310M 板。我个人避免购买二手主板，因为如果不小心处理，很容易损坏英特尔主板上的针脚。此外，对二手汽车的节省也不是很大。
GPU
照片由 Christian Wiediger 在 Unsplash 上拍摄
我再次做了功课，并开始在网上搜索关于深度学习的 GPU 的最佳“性价比”。有几十个来源，有些在媒体上也很棒。实际上，他们中的许多人都有一年左右的历史，并表示迄今为止最赚钱的 GPU 是 RTX 2070 或 2060 超级。我需要提到的是，在我构建 PC 的时候，RTX30XX 系列还没有推出，我链接的文章已经更新了 RTX30XX 系列的结果。
我在商店里找不到一个好的 RTX 2070 交易，也不是二手的，所以从一个论坛上选择了一个全新的技嘉 RTX 2060 超级游戏。卖家通过旧故障卡的 RMA 流程获得了该卡。GPU 的可以买二手，但要注意保修。此外，用于加密挖掘的 GPU 不是最佳选择。
有很多关于如何为深度学习选择合适的 GPU 的主题和文章，所以我强烈建议查看一下。在培养基上也有一些好的。
程序存储单元(Program Storage Unit)
PSU 有三种类型。非模块化、半模块化和全模块化。如果你不喜欢太多的电缆，你当然可以选择模块化的。我喜欢半模块化 PSU，因为它们通常有硬连线的 24 针 MBO、8 针 CPU 和一根用于 GPU 的 6 针 PCI-EX 电缆。所有这些都是需要的，所以这样的单位是完全适合我的。我看不出有必要为一个完全模块化的单元支付额外的费用，因为我肯定不会拆下一根 24 针的电缆。
RTX 2060 Super 在满负荷时需要大约 180W，加上系统中的 CPU 和所有“小”用户，我们在满负荷时大约需要 250-275 W。我是一个有点沉默的怪胎，所以一个能持续几年的高于平均水平的 PSU 是必须的。Seasonic 可能是世界上最受欢迎的 PSU 制造商，也有很好的声誉。他们的 PSU 我从来没有问题。谢天谢地，我在当地的一家商店买到了一辆保修 7 年的 Seasonic 核心 GM-650 。
PSU 是一个可以买到二手的部分，如果你确定它不是用于电力加密采矿机。此外，如果是二手的，确保它至少有 4-5 年的保修期，因为 PSU 不是经常更换的部件。
固态硬盘(或硬盘)
由于我们生活在 2020 年，系统中的一个 SSD 对我来说是必不可少的，至少是 250 GB 的操作系统。在硬盘上装有操作系统的 PC 或笔记本电脑上工作是非常痛苦的，Windows 加载时间大约为 1 分钟，或者浏览器需要 20 秒才能打开。在亚马逊上，250 GB 的固态硬盘从 30 美元起，到目前为止，这是配置你的电脑时最划算的 30 美元。没有任何其他部件能比固态硬盘提供更大的性能提升，只需 30 美元。
现代 SSD 支持两种标准，SATA 和 m.2。我不会深入研究它们之间的差异，因为这超出了本文的范围。点击这里了解更多信息。
就我而言，我在二手市场上找到了很多东西，我买了一台英特尔 660p 的 m.2 设备，还找到了一台 Kingston A400 sata 设备，两者的大小都是 500GB。英特尔 one 作为系统驱动器，因为它的读/写速度更快。在购买之前，请检查机器学习模型的空间要求以及您计划用机器做的任何其他工作。对我来说，有 1 TB 的可用空间就足够了。
SSD 在几个月的日常使用后的统计数据(图片由作者提供)
固态硬盘可以购买二手，但一定要检查写入的数据量，因为固态硬盘的缺点是“有限”的生命周期。正如在我的例子中看到的，我在使用水文模型时对它进行了一些磨损，这些模型往往会对驱动器进行大量的写入。
情况
在这里，我寻找一个体面的情况下，不会打破银行。对我来说，外表排在第二位，建筑质量和空气流通排在第一位。遗憾的是，二手箱子的市场并不大。通常情况下，情况并不乐观。此外，由于一个好的情况下可以找到像 70 美元，我去了当地的 PC 零件经销商，并得到了一个安泰克 P6 m-atx 的情况下，折扣为 39 美元。该案件有体面的气流结合高于平均水平的外观(至少在我看来)和足够的空间固态硬盘。我喜欢整洁的外观，因此在管理线缆时格外小心。
其他部分
我们忘记了什么？如上所述，通过机箱的气流是很重要的，因此请确保您的机箱预装了风扇，或者在售后加装了风扇。我选择了北极 P14 风扇，因为他们的性价比很高。此外，售后 CPU 冷却器是一个好主意，如果你喜欢安静。这里，使用了北极冷冻机 34。这是一个 20 美元的 CPU 冷却器，非常适合中高端 CPU(如果不是超频的话)。水冷也是一个选择，如果你想要一个更狂热的建筑。对于中档建筑，像这样的，空气冷却就足够了。
结论和最终想法
最终建成(图片由作者提供)
在这里，我提出了我对在考虑预算的情况下构建深度学习机器这一主题的想法。我想给我的意见，哪些部分和为什么可以买到二手。最后的结果可以在这里看到。我设法用不到 1000 美元的预算建造了一台像样的深度学习 PC，仅在 CPU 和 GPU 上我就节省了近 300 美元。总共大约 400 美元。这是一个很好的节省，它使我的构建延迟了 3-4 周，并花费了我一些努力去寻找好的交易。
但是，我再次建议，你只去二手的某些组件，只有当你可以确定这个特定的部分没有损坏，并有适当的保证。应避免使用无保修的零件。
如果你喜欢我的文章，欢迎在媒体或 LinkedIn 上关注我。干杯！
如何为数据科学选择合适的笔记本电脑
数据工程 101
流行的开源笔记本框架的深入比较。
如果你是一个大数据爱好者，你可能使用过(或者至少听说过) Jupyter Notebook ，这是数据科学社区中事实上的开源笔记本框架。但是，您知道其他可能更适合您的数据科学项目的笔记本工具吗？
在这篇博文中，我将比较一系列开源笔记本，包括 Jupyter、Zeppelin、Spark Notebook 和 Polynote，以帮助您选择最适合您的分析用例的笔记本。
在我们开始之前…
以下是我们将对每个笔记本选项进行评估的主要功能列表:
- 内核:我可以使用哪些编程语言？我可以在同一个笔记本中用多种语言编写代码吗？
- 版本控制:笔记本和 Git 集成的怎么样？
- 数据可视化:绘图的灵活性如何？
- 社区:虽然社区大小不是产品的特性，但是一个大的用户社区意味着更好的文档，更成熟的插件，以及当你需要帮助时更容易排除故障。
Jupyter 笔记本
来源: Jupyter 笔记本
截至今天，Jupyter 无疑是最受欢迎的笔记本框架。它支持超过 40 种编程语言，包括 Python、R、Julia 和 Scala。虽然基本的 IPython 内核不允许在单元之间切换语言，但是你可以安装一个第三方工具，比如 BeakerX 和 SoS 来实现这个特性。
自从朱庇特笔记本(。ipynb)本质上是 JSON 文件，用户可以使用 Git 轻松地控制笔记本的版本，Github 可以在浏览器上非常好地显示笔记本。如果您更喜欢使用Jupyter Lab(Jupyter 的一个扩展的类似 IDE 的用户界面)，您可以添加一个 Github 扩展来使您的 Git 工作流更加容易。像 matplotlib 和 plotly 这样的流行绘图库与 Jupyter Notebook 很好地集成在一起。
在所有可用的开源笔记本框架中，Jupyter 拥有最大的用户群体。截至 2018 年 9 月，GitHub 托管了超过250 万台公共 Jupyter 笔记本。超过 15，000 个与 Jupyter 相关的问题在 Stackoverflow 上得到回答。JupyterCon 是一个致力于 Jupyter 社区的系列会议，每年由 Project Jupyter 和 O’Reilly Media 主办。
阿帕奇齐柏林飞艇
来源:阿帕奇·泽普林
Apache Zeppelin 可能是分析社区中第二受欢迎的笔记本电脑。Zeppelin 支持三种编程语言:Python、R 和 SQL。它与 Apache Spark 有着惊人的内置集成，允许用户使用 JDBC 无缝查询许多数据库系统。Zeppelin 还支持同一笔记本中的多种解释器/语言。
齐柏林笔记本(。json)可以由 Git 进行版本控制，但不幸的是，Github 目前只将它们显示为纯文本文件，这使得没有本地或托管实例的笔记本很难共享。然而， ZEPL 可用于在浏览器中重新呈现公共笔记本。
Zeppelin 的一个独一无二的特性是，它让用户可以像 BI 仪表板一样调整和排列笔记本单元格，而在其他笔记本框架中，用户根本不允许移动单元格。
火花笔记本
来源:星火笔记本
Spark Notebook 构建在用于内存数据处理的顶级分析引擎 Apache Spark 之上。Scala 是 Apache Spark 唯一支持的编程语言。SparkContext 是现成的，它为每个 Spark 会话生成单独的 JVM，以避免潜在的冲突。
目前 Github 无法显示 Spark 笔记本(。snb)而且目前还没有共享 live 笔记本的托管服务。数据可视化选项似乎也很有限。
截至目前，Spark Notebook 的用户群体相对较小，因为很难在网上找到示例和指南。
波利诺特
来源:开源的 Polynote:一个 IDE 启发的多语言笔记本
Polynote 是网飞在 2019 年末开源的一款全新笔记本工具。用户可以用 Scala(有一流的支持)、Python 和 Polynote 中的 SQL 编写代码，并且可以在单元格之间切换语言和共享变量(又名 polyglot )。
Polynote 共享相同的文件扩展名(。ipynb ),这样它们也可以被版本控制并显示在 Github 上。
Polynote 已经内置了与 matplotlib 和 Vega 的集成。此外，它有一个自动完成的编辑器来提高您的工作效率，还有一个额外的内核状态面板来让您更清楚地了解正在运行的作业。
Polynote 仍处于早期阶段，但许多数据科学爱好者已经在尝试它了。就我个人而言，我非常期待看到它变得更加稳定，增加更多的功能。
想了解更多关于数据工程的知识？查看我的 数据工程 101 专栏关于走向数据科学:
阅读《走向数据科学》中关于数据工程 101 的文章。分享概念、想法和…
towardsdatascience.com](https://towardsdatascience.com/tagged/data-engineering-101)
如何在 Python 中为投资组合挑选不相关的股票
一个简单的 Python 代码，用来挑选标准普尔 500 相关性最低的股票
马库斯·温克勒在 Unsplash 上的照片
有价证券投资是一种迷人的投资，有可能带来令人满意的回报。根据现代投资组合理论，选择相关性低的股票或 ETF 总是一个好主意。
让我们看看为什么以及如何在 Python 中测量股票相关性来选择股票。
来自《走向数据科学》编辑的提示: 虽然我们允许独立作者根据我们的 规则和指导方针 发表文章，但我们并不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的 读者术语 。
什么是线性相关？
股票之间的相关性是衡量一只股票的回报如何影响另一只股票的回报。如果两只股票高度相关，它们可能会同向波动(即，如果一只股票价格上涨，另一只股票价格也会上涨)或反向波动。
从数学上讲，两只股票之间的线性相关指数，比如说 a 和 b ，定义为:
其中分子是股票之间的协方差，分母是标准差的乘积。
这个数字的范围是从-1 到 1。如果它是-1，股票向相反的方向移动(即，如果一只股票上涨，另一只股票下跌)，如果它等于 1，股票完全向同一方向移动。如果它等于 0，股票是不相关的，它们的运动是相互独立的。我们必须寻找这些不相关的股票。
为什么要选择不相关的股票？
如果我们建立一个由一些股票组成的投资组合，它们的权重是 x ，投资组合的方差是:
因此，只要股票之间的相关性为正，我们投资组合的方差相对于方差之和就会增加，其风险也会增加。有些人可能会说，我们会喜欢负相关的股票，但在这种情况下，不会有任何回报，因为如果一只股票上涨，另一只股票下跌，净回报为 0。
所以，我们的想法是保持我们的股票不相关，以消除第二项，避免更高的方差。这是现代投资组合理论的一个分支的目的，有数学工具允许我们根据权重 x 优化方差。在这篇文章中，我们将重点选择那些线性相关性的绝对值几乎等于 0 的股票。
代码
在文章的这一部分，我们将研究标准普尔 500 股票，我们将找出相互关联度较低的几只股票。一切都可以在我的 GitHub 资源库中找到:https://GitHub . com/gianlucamalato/machine learning/blob/master/Stocks _ correlation . ipynb
我们将使用 pandas 库来执行所有的计算，而 S & P 成分的列表将从这个 GitHub 存储库下载:https://GitHub . com/datasets/S-and-P-500-companies/tree/master/data
首先，让我们导入一些有用的库:
然后，我们希望获得历史时间范围内的所有标准普尔 500 股票，例如从 2018 年到 2019 年。让我们先下载标准普尔 500 的历史数据，以获得这一时期的有效交易日。
现在，我们可以滚动 tickers 数据框并下载每个符号的历史数据。由于我们列表中的一些股票可能已经被摘牌，或者可能太新，我们检查每只股票是否在标准普尔 500 的交易日进行过交易。如果没有，我们丢弃库存。如果股票不再是标准普尔 500 的一部分，或者根据我们的历史时间范围，它太新，就会发生这种情况。因为我们想有一个均匀的时间间隔，我们丢弃这样的股票。
然后，对于每只股票，我们计算每日百分比回报。
这是总数据帧。每一列都是股票的每日收益，股票的名称就是列的名称。索引是日期。
我们现在可以使用 Pandas 的“corr”方法计算每只股票之间的线性相关性，然后我们可以使用“melt”方法将列转置为行来规范化该表。
如你所见，我们有每只股票与自身的相关性(显然是 1)，我们得到股票 A 与股票 B 的相关性，以及股票 B 与股票 A 的相关性，这是相同的，因为相关性是对称的。我们可以去掉这些无用的记录，计算相关指数的绝对值。
然后，我们可以按绝对值升序对表进行排序，这样我们在第一条记录中就有了相关性较低的股票对。
最后，这是 2018-2019 年期间标准普尔 500 相关性较低的股票对的表格。
结论
计算股票之间的相关性是有用的，每个投资组合投资者都必须这样做。然而，相关性可能会随着时间的推移而变化，因此定期计算它可能会有助于调整投资组合，使其不会遭受可能会增加整体风险的突然相关性。
如何规划和组织数据科学/分析项目？
开展数据科学/分析项目总是需要时间，而且从来都不容易。一个成功而全面的分析项目远远不止编码。相反，它涉及复杂的计划和大量的沟通。
分析项目的生命周期是怎样的？
要完成一个数据科学/分析项目，您可能需要经历五个主要阶段，从了解问题和设计项目开始，到收集数据、运行分析、展示结果、做文档和自我反思。
由作者创建
我有一种强烈的感觉，运行一个分析项目非常类似于建造一座房子。首先，架构师会见他/她的客户，了解他们的需求，并提出一个可行的蓝图(理解和计划)。
然后需要收集建筑材料，如水泥、钢材、砖块等。你必须了解建筑材料的特性，选择合适的建筑材料。否则，你最终可能会拥有一个很容易倒塌的房子。这就像一个数据收集过程，你必须做一些 EDA 或功能工程来理解数据，并找到正确的数据来解决你的分析问题，否则你可能无法从你的分析中获得可靠或具体的结果！
有了建筑材料和蓝图，你就可以开始建房子了(运行分析)。施工完成后，需要进行房屋检查和质量检查，以确保安全。同样，我们需要记录我们关于方法、结论和限制的分析项目。
了解&计划
如果问我整个周期最关键的阶段，我会毫不犹豫地说理解和规划，因为数据科学和分析的主要目的不是用花哨的技术创建项目，而是解决实际问题。因此，分析项目的成功在很大程度上取决于您对情况的了解程度、对问题的定义以及将业务问题转化为分析问题的能力。从这个角度来看，花时间思考您的分析项目的更广泛的背景总是值得的。
- 提问
通常情况下，一个分析项目始于一个与业务合作伙伴会面的启动会议。他们会提供一些背景信息，并简单谈谈他们在寻找什么。问聪明的问题总是会让你更好地理解业务涉众的痛点和需求。这里有一些你可以问的问题。
由作者创建
- 分析计划
在开始分析之前，让我们制定一个分析计划，并召开另一次跟进会议来回顾问题并强化预期。
它将提供该计划的高层次概述，给出接下来步骤的清晰画面，并从业务方面绘制技术行动和更大画面之间的联系。以下是我的分析计划中的一些关键要素:
由作者创建
不要让数据科技成为一个谜。尝试用通俗易懂的语言对方法进行简要描述，概述用例及场景，并总结优点和局限性。避免复杂的公式或函数，而是专注于该方法如何帮助解决问题。
完成一个分析项目可能需要几周时间，有时甚至更长。一个项目持续的时间越长，一些变量在工作中捣乱的可能性就越大。因此，在你的项目开始之前，第一件事是解开你完成项目必须做的所有步骤。然后估计完成这些任务所需的时间框架，并标记一些里程碑。
由作者创建
建议你不要只做一个最终演示，而是在项目中间设立一些检查点，与你的利益相关者接触并获得他们的反馈，这样你就可以及时进行调整。
由作者创建
如何组织项目并跟踪进度
- 利用项目管理工具
当你在处理一个复杂的分析项目，并且需要与多个团队合作时，比如工程、产品和业务等，简单的待办事项列表或基于 excel 的跟踪工具是不够的。
Jo Szczepanska 在 Unsplash 上拍摄的照片
但是，您可以利用专用的项目管理工具和软件。如果你去谷歌简单地搜索项目管理工具，许多工具会抓住你的注意力，如 Asana，Trello，Monday.com JIRA 等。我打赌你会根据你的团队规模和你喜欢的工作方式找到合适的工具。但是，idea 赢得了我的心，因为它是一个一体化的工作空间，将几个工作应用程序融为一体。我真的很讨厌有多种工具用于不同的目的，所以你可以想象，“多合一”是最有效的营销信息来转换我。
对我来说，在一个地方做计划、跟踪、知识分享和写博客是一个很棒的选择。信不信由你，它还提供模板，以方便旅行计划，并协助您跟踪工作申请的进展。
- 冲刺规划
你有一个强大的工具。就像你的私人助理。如何保证协作，让轮子运转起来？先说冲刺规划。
对于那些不熟悉 sprint 概念的人来说，sprint 是一个短暂的、有时间限制的时期，团队在这个时期努力完成一定数量的工作。
sprint 让项目更容易管理，让团队更快更频繁地交付高质量的工作，并给他们更多的灵活性来适应变化。
进行冲刺规划的首要任务是决定冲刺的长度。尽管没有硬性规定每个 sprint 应该持续多长时间，但它必须足够长以确保任务可以完成，同时它也应该足够短以使需求和目标保持不变。
在 sprint 规划会议上，整个团队将调整即将到来的 sprint 的目标，并计划有助于实现该目标的工作。这些任务将被逐项列出，按优先顺序排列，分配给团队成员，并记录到即将到来的 sprint 的板上。
- 每日一站
Sprint 规划是为了定义要实现的目标和要交付的任务，以推动项目的进展，而 5 到 10 分钟的每日例会将有助于规划与执行相一致。更具体地说，就是让团队达成共识，明确优先级，避免一些常见的障碍。
由作者创建
长话短说，这里有三个大家都会回答的基本问题:
- 你昨天做了什么？
- 你今天要做什么？
- 什么阻碍了你的发展？
由作者创建
不要忽视文档和反思的重要性
我在数据分析/数据科学领域已经工作了六年多。我希望在我开始职业生涯时就知道的一件事是，文档和反思与分析本身同等重要。由于你所做的所有分析项目都有可能作为一个闪亮的项目进入你的简历，然后它们将成为面试的谈话点，一旦完成，总结和框定你的分析工作对你刷新记忆、巩固所有材料和构建故事非常有益。
- 记录并框定你的分析
你可以遵循这个框架，包括情况、问题、解决方案和后续步骤(SPSN)。
由作者创建
首先，描述当前的状态和痛点，然后描述问题并大声说出该项目的业务影响。
最关键的部分是解决方案，在这里您概括了高层次的方法，并逐步提供关于数据和分析的细节。然后记录从您的分析中得出的结果、见解和可行的建议。
请注意，没有完美的数据科学项目。开诚布公地谈论你的项目的注意事项和局限性。大声说出你的分析可以解决的问题是很好的，同时了解什么样的问题不能回答也是很有价值的。
最后一部分是下一步。潜在的下一步将是测试新的方法以提高准确性，包括新的数据源，或者自动化整个过程以使结果每天都显示出来等。
同时，不要忘记通过创建一个故事网格来进行自我反思，并将你在每个分析项目中遇到的一些例子和情况映射到以下五个类别中。
由作者创建
希望它有助于促进您的分析/数据科学项目的整个过程！
如何利用强化学习玩井字游戏
关于 Q-learning 的简单教程
Q-learning 是一种出色而基本的强化学习方法，由于深度学习革命，它最近取得了很多成功。虽然本教程不会解释什么是深度 Q 学习，但我们将通过原始的 Q 学习算法来教一个代理如何玩一个井字游戏。尽管它很简单，但我们会看到它能给出极好的结果。
首先，我们将通过一些必要的背景知识来快速了解强化学习，然后我们将介绍 Q-learning 算法，最后是如何实现它来教代理玩井字游戏。
为了理解本教程，不需要有任何关于强化学习的知识，但它将有助于对微积分和线性代数有一个基本的了解。最后，我分享了我自己的 Github 知识库，里面有我解释的东西，你可以免费查看，如果你感兴趣，点击这里。
强化学习概述
强化学习的目标是当智能体在不同状态的环境中运行时，根据某种奖励函数优化智能体的行为。对于本教程，环境是井字游戏，它有明确定义的动作，代理必须决定选择什么动作来赢得游戏。此外，代理人将因赢得游戏而获得奖励，这鼓励它在游戏中学习好的策略。
强化学习的一个常见框架是(有限)马尔可夫决策过程 (MDP)。它帮助我们定义一组动作和状态，代理的决策是基于这些动作和状态的。
一个 MDP 包括
- 一组有限的动作*(在游戏板上放置标记的位置)*
- 状态的有限集合(游戏板的给定配置)**
- 一个奖励函数 R(s，a) ，该函数基于在状态 s 中执行动作 a 来返回值。
- 一个转移函数 T(s，a，s’)
当执行动作时，转换函数给出从状态 s 移动到***s’*的概率。当我们处在一个不确定某项行动是否总能产生预期结果的环境中时，这是必要的。然而，在井字游戏中，我们确切地知道每个动作会做什么，所以我们不会使用这个。
状态空间由所有可能的游戏配置组成。在每个状态下，我们可以执行一组可用的操作。在这个例子中，当前玩家有六个可能的动作要执行。(图由作者提供)
MDP 框架帮助我们形式化了这个问题，根据当前的状态，确定哪些行为将使代理人在游戏中的总报酬最大化。奖励函数 R(s，a) 会非常简单:
- 如果代理人从执行一个赢得游戏的动作—，那么 R(s，β)= 1。
- 否则，如果代理犯了一个错误，选择了错误的动作从而输掉了游戏，那么 R(s，γ)=-1。
- 否则，当上述情况都没有发生时，奖励简单来说就是 R(s，a) = 0。
在强化学习中，我们找到了一个最优策略，代理使用它来决定采取哪些行动。由于我们使用 Q-learning，我们将简单地把我们的策略表示为当代理处于状态 s 时最大化函数*【s，a】的动作。这是 Q-learning 的核心，所以让我们来看看如何计算这个函数。*
对于游戏中的每个状态，每个动作都与一个 Q 值相关联。最佳策略是选择价值最高的行动。在这个具有状态 s 的例子中，下一轮属于玩家 X，并且很明显哪个动作具有最高的预期奖励，因为 X 即将获胜。
用贝尔曼方程更新
Q(s，a) 的解释是:如果代理人在状态 s 中拾取动作 a 则 Q 是游戏结束时给出的期望奖励。由于代理人想使其报酬最大化，它想选择使 Q 最大化的行动。
在游戏的这种状态下，我们显示当前玩家 X 的 Q 值的场景示例。通过将下一个标记放置在最大值所在的位置，玩家将赢得游戏并获得奖励。(图由作者提供)
为了计算 Q(s，a) ，代理必须探索所有可能的状态和动作对，同时从奖励函数*【R(s，a)*** 获得反馈。在井字游戏的情况下，我们通过让代理与对手玩许多游戏来迭代更新 Q(s，a) 。利用 Q 学习算法，用于更新 Q 的等式如下:**
- 我们执行一个动作 一个 当前状态 s.
- 最后一项展望未来并返回可用的最大 Q 值，【ŝ】是执行动作后的新状态。然后，动作—是下一个状态 ŝ 的最佳动作。
- 学习率 α 决定我们在多大程度上覆盖旧值，我们将使用 α = 0.1 。
- 折扣因子 γ 决定了与当前时间步长 t 的奖励相比，未来奖励的权重。我们将使用 γ = 0.9 。
这个等式基于强化学习中众所周知的等式，称为贝尔曼等式。让我们看看如何使用这个等式来教导我们的代理。**
Q 学习算法的实现
**要得到一个训练有素的代理，我们需要学习 Q(s，a) 的值。这将通过让两个代理相互竞争来实现。我们将引入一个概率 ε 每个智能体挑选一个随机动作，否则它将根据 Q(s，a) 挑选最佳动作。用这种方式，我们确保到平衡学习，使得代理有时探索新的动作，而其他时候利用代理已经学习的信息。
这个训练阶段可以用 Q 学习算法的下列伪代码来描述:
**Initialise: Q(s,a) = 0, starting state s,
starting player P, iterations Nfor t = 0 : N With probability **ε** :P picks random action a
Else, pick action a that maximise Q(s,a) Observe new state ŝ and reward R(s,a) If current player is our agent,
update Q(s,a) = (1-α)Q(s,a) + α[R(s,a) + γ**max(*Q(ŝ,â)*)*] s = ŝ
Switch turn, P = the other player**
注意迭代次数 N 一定比较大，我一直用 50 万左右。另外， Q(s，a) 可以实现为 Python 字典，或者如果我们将 (s，a) 表示为整数，则可以实现为二维数组。最后，可以随时间改变概率 ε ，以强调早期迭代中的更多随机探索，这可能会加快学习。
在你用算法训练了你的代理之后，你可以保存*【Q(s，a)】的值，当你想和代理对战的时候加载它。然后，代理人只需通过选择最大化【s，a】*的行动来遵循最优策略。虽然代理并没有因为井字游戏的简单而变得非常聪明，但是如果你想学习如何实现 Q-learning 并看到它的工作，尝试一下仍然很有趣。
摘要
总之，本教程首先解释了马尔可夫决策过程(MDP)框架，以及它是如何用于强化学习的。我们用状态、动作和奖励函数模拟了井字游戏。在此基础上，我们定义了函数 Q(s，a) ，该函数通过在状态*【s中选择动作来量化期望的奖励，并通过反复玩游戏展示了计算*【Q(s，a)*** 的公式。***
我希望你喜欢这个教程，如果你有任何问题，欢迎在这里或通过 Twitter 联系我。最后，如果你想看看这在实践中是如何工作的，那就在下面链接的我的 Github 资源库中查看我的实现。
https://github.com/RickardKarl/bill-the-bot
如何以友好的方式用加权调查绘制李克特量表
如果你在 R 中使用过 Likert scale 可视化，你可能知道 Jason Bryer 的 Likert 包。尽管这是一个很棒的包，但它在处理加权调查时的能力是有限的。在寻找解决方法时，我发现了这个的好帖子，它解释了这个过程，但是使用了很多我不太熟悉的 base R 函数。最后，我设法以一种适合我的工作流程的 dplyr 友好的方式复制了这个过程，并认为它可能对面临同样问题的其他 R 用户有用。在这里我会指导你整个过程。
数据
为了使这成为一个非常普遍的情况，让我们生成一些您可以在加权调查中找到的随机数据。我们的数据框将包含每个回答者的 id、他们对 5 个不同问题的 Likert 量表的回答、一个表示他们所代表的群体的字母，以及分配给每个回答者的权重。
library(tidyverse)n_sample <- 100sample_data <- tibble(
id = seq(1, n_sample, 1),
q1 = sample.int(5, n_sample, replace = TRUE),
q2 = sample.int(5, n_sample, replace = TRUE),
q3 = sample.int(5, n_sample, replace = TRUE),
q4 = sample.int(5, n_sample, replace = TRUE),
q5 = sample.int(5, n_sample, replace = TRUE),
group = sample(c("A","B"), n_sample, replace = TRUE),
weight = runif(n_sample, 1, 3)
)
获得加权结果
我们这里的主要目标是对我们的结果进行加权(否则我们会直接使用 Likert 包)。为此，您可以使用超级有用的调查包，它为您提供了许多处理调查数据的工具。这个包与我通常使用的 tidyverse 工具不太兼容，但幸运的是，我们可以使用 srvyr 包，它允许我们使用 dplyr 语法处理调查包函数。
首先，我们将把数据转换成一个调查对象。然后，我们将定义一个函数来提取单个问题的加权结果，最后，我们将应用这个函数来获得每个问题的结果。
library(srvyr)# Tranform sample data into survey data
survey_data <- sample_data %>%
as_survey_design(id = 1,
weights = weight)# Function that gets the weighted frequency of answers for a single question
get_weighted_results <- function(q, survey_data){
survey_data %>%
group_by(group) %>%
summarize(a = survey_total(get(q) == 1),
b = survey_total(get(q) == 2),
c = survey_total(get(q) == 3),
d = survey_total(get(q) == 4),
e = survey_total(get(q) == 5)) %>%
pivot_longer(-group,
names_to = "ans",
values_to = "freq") %>%
filter(!str_detect(ans, "se"))
}# Apply function to each question and calculate proportion
likert_results <- tibble(q = c("q1", "q2", "q3", "q4", "q5")) %>%
mutate(results = map(q, get_weighted_results, survey_data)) %>%
unnest(results) %>%
group_by(q, group) %>%
mutate(prop = freq / sum(freq)) %>%
ungroup()
让我们花点时间来研究一下我们的新函数有什么作用:
- 获取您的调查数据并按预定义的变量对其进行分组。这里我假设你有一个分组变量:如果没有，就忽略这一步。
- 汇总得到每个可能答案在李克特量表上的加权频率。请注意，我将每个答案保存在不同的信中。稍后我们将把这些信件翻译成文本。
- 将我们的数据框转换为整齐的格式。当我们开始用 ggplot2 绘图时，这将很有帮助。
- 过滤包含“se”的行。默认情况下，survey_total 函数也将返回总数的标准误差。我们不会在这里使用它，但是如果需要的话，你可以把它留下。
然后，我们从头开始创建一个新的数据框，其中有一列包含我们的 Likert 问题的变量名。我们将函数应用于该列，对结果进行去嵌套，并计算我们将要绘制的比例。您应该会得到如下所示的数据框:
我们将要绘制的整洁的数据框应该如下所示
制作我们的绘图功能
在我的例子中，我有许多李克特量表问题要在不同的分组中显示，所以我认为最方便的解决方案是创建一个函数来绘制我需要的任何问题。这个函数很长，但是不要害怕，我会一步一步地指导你。让我们来看看吧。
plot_weighted_likert <- function(x, my_labels, likert_results) {
# Filter data for questions needed
likert_results2 <- likert_results %>%
filter(q %in% x)
# Create data frame with labels
prop_labels <- likert_results2 %>%
mutate(
position = case_when(
ans == "a" | ans == "b" ~ "left",
ans == "c" ~ "center",
ans == "d" | ans == "e" ~ "right"
)
) %>%
group_by(q, group, position) %>%
summarize(label = sum(prop * 100)) %>%
pivot_wider(names_from = position,
values_from = label)
# Data frame with right side values
high_columns <- likert_results2 %>%
filter(ans == "c" | ans == "d" | ans == "e") %>%
mutate(prop = case_when(ans == "c" ~ prop / 2 * 100,
ans == "d" ~ prop * 100,
ans == "e" ~ prop * 100,)) %>%
arrange(ans)
# Data frame with left side values
low_columns <- likert_results2 %>%
filter(ans == "a" | ans == "b" | ans == "c") %>%
mutate(prop = case_when(ans == "a" ~ prop * 100,
ans == "b" ~ prop * 100,
ans == "c" ~ prop / 2 * 100)) %>%
arrange(ans)
# Define empty ggplot object
p <- ggplot() +
# Add central black line
geom_hline(yintercept = 0) +
# Add right side columns
geom_bar(
data = high_columns,
mapping = aes(x = group,
y = prop,
fill = ans),
position = position_stack(reverse = TRUE),
stat = "identity"
) +
# Add left side columns
geom_bar(
data = low_columns,
mapping = aes(x = group,
y = -prop,
fill = ans),
position = "stack",
stat = "identity"
) +
# Left side labels
geom_text(
data = prop_labels,
mapping = aes(
x = group,
y = -100,
label = paste(round(left) , "%", sep = "")),
hjust = 1,
color = "black",
size = 3
) +
# Central labels
geom_text(
data = prop_labels,
mapping = aes(
x = group,
y = 0,
label = paste(round(center) , "%", sep = "")),
hjust = 0.5,
color = "black",
size = 3
) +
# Right side labels
geom_text(
data = prop_labels,
mapping = aes(
x = group,
y = 100,
label = paste(round(right) , "%", sep = "")),
hjust = -0.2,
color = "black",
size = 3
) +
# Scale formatting
scale_y_continuous(
breaks = seq(-100, 100, 50),
limits = c(-105, 105),
labels = abs
) +
# More formatting
theme(legend.title = element_blank(),
legend.position = "bottom",
axis.ticks = element_blank(),
strip.background = element_rect(fill = "#F0F0F0",
color = "#F0F0F0"),
panel.background = element_blank(),
panel.border = element_rect(
colour = "#F0F0F0",
fill = NA,
size = 1.5)
) +
facet_wrap(~ q, ncol = 1) +
coord_flip() +
ylab("Proportion") +
xlab("") +
# Change Likert labels
scale_fill_discrete(labels = my_labels)
# Print the plot
p
}
好吧，那么，我们在这里做什么？
- 我们的函数将采用一个包含我们要绘制的问题名称的字符向量，另一个包含我们的 Likert 量表标签的字符向量，以及我们创建的数据框。
- 第一步是过滤数据框，因为我们只对给定的一组问题感兴趣。
- 然后，我们计算将出现在绘图左侧、中间和右侧的标签。和最初的 Likert 包一样，在每一边，我们都要显示极端答案的百分比。为此，我们创建一个名为 position(左、右或中心)的新列，计算每个位置的比例总和，最后将数据框转换为更宽的格式，以便于使用。
- 现在，我们将准备绘制两个新的数据框，分别包含较低和较高的值。中心值将除以 2，每一半将放入其中一个数据框中。我们必须按“ans”列排列每个数据框，以便在我们的绘图中正确堆叠值。
- 我们准备好开始策划了。首先，我们创建一个空的 ggplot 对象并添加我们的中心线。
- 然后我们添加两个
geom_bar，用于我们的左列和右列。这里要注意两点:对于左侧的值，我们将-value绘制为我们的 y 美学，并且我们在右侧的条中指定了position_stack(reverse = TRUE),因此它们按照我们想要的顺序堆叠。 - 然后我们添加三个
geom_text来绘制百分比标签。由于我们的标签目前是十进制数字，我们将它们四舍五入，并粘贴一个百分号。对于hjust参数，我只是使用了最初的 Likert 包中的默认值。 - 接下来，我们对 y 轴进行格式化。这里我在
labels参数中传递了abs函数，所以我们的标签从 100 到 0 再到 100。 - 然后我用
theme做一些格式化。在这种情况下，我选择了一个与原来略有不同的面板边框，因为我更喜欢它。之后，我加上刻面，翻转天平，加上标签， - 最后，我添加了一个
scale_fill_discrete来将我的“a，b，c，d，e”标签更改为所需的标签。
结果
让我们看一些由此产生的李克特曲线图的例子。(不要忘记定义一个 labels 对象，因为函数中没有默认的对象)。
my_labels <- c("Very\nunsatisfied",
"Unsatisfied",
"Neutral",
"Satisfied",
"Very\nsatistifed")plot_weighted_likert(c("q1"), my_labels, likert_results)
plot_weighted_likert(c("q2", "q3", "q4"), my_labels, likert_results)
plot_weighted_likert(c("q1", "q2", "q3", "q4", "q5"), my_labels, likert_results)
只有一个问题的情节
三个问题的情节
五个问题的情节
就是这样！我希望这有所帮助，如果您有任何疑问，请告诉我。
一些改进
你可能需要对你的情节做一些我在这里没有提到的改进。我将简要阐述这些问题:
- 个性化的颜色。为此，将
scale_fill_discrete替换为scale_fill_manual，保留 labels 参数，并将一个 5 色矢量添加到values参数中。 - 分组顺序。在结果图中，我们将 B 组绘制在 a 组之上。要定义绘制组的顺序，您可以使用
factor函数并指定组的顺序来改变group列。 - 问题标签。这里最简单的方法是让您的
q列包含问题文本。通过这种方式，该功能将继续按预期工作。您还可以添加一个新的包含问题文本的text列。如果你这样做，你将不得不修改函数，以便它在需要时使用text而不是q作为变量。 - 问题顺序。绘制问题文本时，您的问题可能会以不同于预期的顺序显示。为了解决这个问题，您可以创建一个
text_order向量，它按照您希望问题显示的顺序包含问题，并使用factor函数改变likert_results2数据框中的text列(在函数内部，在您过滤它之后),并传递这个向量。
如何用 Logzero 练习 Python 中的日志记录
为您的 Python 项目提供强大而有效的日志记录。
Logzero 是由 Chris Hager 创建的 Python 包，它简化了 Python 2 和 3 的日志记录。Logzero 作为打印语句更容易显示信息和调试细节。
如果你想知道什么是日志记录，我推荐你阅读我之前写的关于“如何用 Python 日志记录模块运行机器学习实验”的文章，尤其是前 3 节。
在那篇文章中，您将了解到:
- 什么是日志记录？
- 为什么日志记录很重要。
- 测井在不同技术行业中的应用。
Logzero 具有不同的特性，使得它更易于在 Python 项目中使用。这些功能包括:
- 轻松记录到控制台和/或文件。
- 提供完全配置的标准 Python logger 对象。
- 漂亮的格式，包括控制台中特定级别的颜色。
- 适用于各种字符编码和特殊字符。
- 兼容 Python 2 和 3。
- 不再依赖 Python。
安装。
使用 pip 运行安装 logzero。
pip install -U logzero
你也可以从公共 Github repo 安装 logzero:
git clone https://github.com/metachris/logzero.git
cd logzero
python setup.py install
基本例子。
我们将从一个基本的例子开始。在 python 文件中，我们将从 logzero 导入日志记录器，并尝试 4 种不同的日志记录级别示例。
#import logger from logzero
from logzero import loggerlogger.debug(“hello”)
logger.info(“info”)
logger.warning(“warning”)
logger.error(“error”)
输出是彩色的，易于阅读。
对数零输出
如你所见，每一关都有自己的颜色。这意味着您可以通过检查颜色轻松识别级别。
将日志写入文件
大多数时候 Python 用户倾向于在文件中写日志。系统运行时，您可以将日志保存在文件中，并查看它们以进行错误检查和维护。您还可以设置一个文件来保存 legzero 中的所有日志条目。
我们将从 logezero 导入日志记录器和日志文件。logfile 方法将帮助我们配置日志文件来保存我们的日志条目。
现在，您的日志条目将被记录到名为 my_logfile.log 的文件中。
#import logger and logfile
from logzero import logger, logfile
#set logfile path
logfile('my_logfile.log')
# Log messages
logger.info("This log message saved in the log file")
my_logfile.log 中的输出包含日志级别标签(对于标记为“I”的信息级别)、日期、时间、python 文件名、行号和消息本身。
[I 200409 23:49:59 demo:8] This log message saved in the log file
旋转日志文件。
您不需要一个单独的日志文件来保存所有的日志条目。这导致系统打开和关闭大量日志文件。
您可以使用 maxBytes 和 backupCount 参数来允许文件以预定的大小翻转。当大小即将超出时，文件将被关闭，并自动打开一个新文件进行输出。每当当前日志文件的长度接近 maxBytes 时，就会发生翻转。如果 maxBytes 或 backupCount 为零，则永远不会发生翻转。
在下面的例子中，我们将 maxBytes 设置为 **1000000 字节(1 MB)。**这意味着当文件大小超过 1MB 时，文件将被关闭，并打开一个新文件来保存日志条目。要保留的备份数量设置为 3。
# Set a rotating logfile
logzero.logfile("my_logfile.log", maxBytes=1000000, backupCount=3)
设置最低日志记录级别。
日志级别是指设置给定日志消息的重要性级别。您还可以通过使用 logfile 方法中的 log level 参数为文件处理程序设置不同的日志级别**。**
在下面的例子中，我们将 loglevel 设置为warning。这意味着低于警告级别的所有日志条目将不会保存到日志文件中。
#import logzero package
from logzero import logger, logfile
import logging
# You can also set a different loglevel for the file handler
logfile("my_logfile.log", loglevel=logging.WARNING)
# Log messages
logger.info("This log message saved in the log file")
logger.warning("This log message saved in the log file")
设置自定义格式化程序。
如何格式化日志记录由您决定。有不同的方法可以格式化你的日志记录。您可以在格式中包含日期、时间和日志记录级别，这样您就可以知道日志是何时发送的以及在什么级别发送的。
以下示例显示了如何配置日志记录的格式。
#import logzero package
import logzero
from logzero import logger, logfile
import logging
#set file path
logfile("my_logfile.log")
# Set a custom formatter
my_formatter = logging.Formatter('%(filename)s - %(asctime)s - %(levelname)s: %(message)s');
logzero.formatter(my_formatter)
# Log messages
logger.info("This log message saved in the log file")
logger.warning("This log message saved in the log file")
在上面的例子中，我们配置了日志格式，包括文件名、日期、时间、日志级别名称、和消息。
这是 my_logfile.log 中的输出:
demo.py — 2020–04–10 00:51:44,706 — INFO: This log message saved in the log file
demo.py — 2020–04–10 00:51:44,707 — WARNING: This log message saved in the log file
自定义记录器实例
除了使用默认的记录器，您还可以使用 logzero.setup_logger(…)。您可以使用不同的参数配置并返回一个完全配置的 logger 实例，如名称、日志文件名称、格式化程序、最大字节数、备份计数、和日志记录级别。
这是一个如何使用自定义记录器实例设置日志记录的工作示例:
import logzero package
from logzero import logger, logfile, setup_logger
import logging
# Set a custom formatter
my_formatter = logging.Formatter('%(filename)s - %(asctime)s - %(levelname)s: %(message)s');
#create custom logger instance
custom_logger = setup_logger(
name="My Custom Logger",
logfile="my_logfile.log",
formatter=my_formatter,
maxBytes=1000000,
backupCount=3,level=logging.INFO)
# Log messages
custom_logger.info("This log message saved in the log file")
custom_logger.warning("This log message saved in the log file")
在上面的例子中，我们已经用不同的配置参数值设置了一个名为 custom_logger 的自定义记录器实例。
包裹
在本文中，您已经学习了如何使用 Logezero Python 包的基础知识和一些示例。您可以在文档中了解更多可用功能。现在您可以开始在下一个 python 项目中实现 logzero 包了。
如果你学到了新的东西或者喜欢阅读这篇文章，请分享给其他人看。在那之前，下期帖子再见！也可以通过 Twitter @Davis_McDavid 找到我
你可以阅读 freecodecamp 的原文。
最后一件事: 在以下链接中阅读更多类似这样的文章。
探索性数据分析逐步指南。
medium.com](https://medium.com/analytics-vidhya/why-you-need-to-explore-your-data-how-you-can-start-13de6f29c8c1) [## 使用投票方法的特征选择
如何应用多种技术来选择 Xverse 包的特性？
medium.com](https://medium.com/analytics-vidhya/feature-selection-by-using-voting-approach-e0d1c7182a21) [## 如何用 Python 日志模块运行机器学习实验
有时候“打印”并不是一个好主意
medium.com](https://medium.com/analytics-vidhya/how-to-run-machine-learning-experiments-with-python-logging-module-9030fbee120e)
如何在 AWS 上免费练习 SQL
通过在真实数据库上练习来提高您的 SQL 技能
弗洛里安·克拉姆在 Unsplash 上拍摄的照片
数据科学家的必备技能之一是使用 SQL 处理数据库。你可能会说这是数据工程师的工作，但数据科学家的角色更倾向于全栈。此外，作为一名数据科学家，你不会希望依赖数据工程师从数据库中检索数据。
有很多教程解释 SQL 语法来完成某些操作。您甚至可以在示例数据库上练习和测试您的查询。然而，这并不是一种非常有效的学习方法。
在你自己的数据库上工作，用 RDBMS(例如 MySQL)运行 SQL 查询，在提高你的技能方面要有效得多。在本文中，我们将在 AWS 上创建一个 MySQL 数据库，并使用 MySQL Workbench 连接到它。
大纲如下:
- 使用 Amazon RDS 创建一个 MySQL 数据库
- 使用 MySQL Workbench 连接到数据库
- 实践部分
你首先需要在 AWS 上创建一个自由层账户。这是非常简单的创建，你不会被收取一毛钱，如果你留在免费层的限制。免费层的范围对于学习来说已经足够了。
如果您已经有一个 AWS 帐户或刚刚创建了一个免费的一级帐户，我们准备开始下面的部分。
1。使用亚马逊 RDS 创建一个 MySQL 数据库
我们将使用 Amazon RDS(关系数据库服务),可以通过在控制台上键入 RDS 来访问它。
(图片由作者提供)
向下滚动一点，点击“创建数据库”框。
(图片由作者提供)
您需要选择标准选项和 MySQL 作为引擎选项。
(图片由作者提供)
你不需要改变版本。确保选择模板下的“自由层”。
(图片由作者提供)
在模板下的 settings 部分中，键入数据库实例的名称、主用户的登录 ID，并创建密码。
(图片由作者提供)
对于数据库实例大小，空闲层只有一个选项，即 db.t2.micro。
对于存储，只需选择通用和默认的 20 GB。确保取消选中“启用存储自动缩放”选项。
(图片由作者提供)
多 AZ 部署不适用于自由层，因此我们将跳过它。
下一部分是“连接性”。选择默认的 VPC。确保为公共访问选择“是”,并创建一个新的 VPC 组。
(图片由作者提供)
创建新的 VPC 组非常重要，因为这将创建一个安全组，允许从您当前使用的设备的 IP 地址连接到所创建的数据库。
对于数据库端口，保留默认值 3306。
在 additional configuration 部分，键入一个初始数据库名称，并将其他两个选项保留为默认设置。
(图片由作者提供)
对于其余的配置部分，默认选择就可以了。确保未选择“监控”选项。
(图片由作者提供)
现在，您可以向下滚动到页面的末尾，并单击“创建数据库”框。
(图片由作者提供)
点击“创建数据库”后，您将被定向到 Amazon RDS 仪表板中的数据库。状态将被视为“正在创建”一段时间，然后变为“可用”。
(图片由作者提供)
2。使用 MySQL Workbench 连接到数据库
下一步是下载同样免费的 MySQL 工作台。
(图片由作者提供)
为您的计算机选择合适的版本，下载，然后安装。
在 MySQL Workbench 控制台上，单击顶部“数据库”部分下的“连接到数据库”。
(图片由作者提供)
将弹出以下屏幕。
(图片由作者提供)
- 主机名:数据库的端点。当您单击数据库实例时，可以看到端点。
(图片由作者提供)
- 端口:3306
- 用户名:创建数据库时输入的用户名(我输入的是 MasterUser1)
- 密码:点击“存储在保险库中”并输入您创建的密码
然后，点击“确定”。
恭喜你！现在，您已经连接到 AWS 上的数据库。MySQL Workbench 将打开一个 SQL 编辑器，这样您就可以开始练习和运行查询了。
在运行查询之前，还有最后一件事要做。单击“schemas ”,然后双击要使用的数据库。现在只有一个。
(图片由作者提供)
3。练习部分
我们现在准备走了。让我们运行几个简单的 SQL 查询。
创建表格
在编辑器中键入以下 SQL 代码，然后单击 run。
(图片由作者提供)
现在，您的数据库中有了一个表。该表的名称是“sample ”,它有 4 列。
要获得该表的概述，在编辑器中键入“DESC 示例”,并运行它。
(图片由作者提供)
插入一行
“样本”表现在是空的。我们可以使用 insert 函数添加条目。
(图片由作者提供)
我已经使用上面的插入查询添加了两个条目。
从表中选择
我们现在可以看到表中的条目。下面的 select 查询将查询表中的所有行。
(图片由作者提供)
结论
我们使用 Amazon RDS 服务在 AWS 上创建了一个 MySQL 数据库，并使用 MySQL Workbench 连接到它。
我们现在可以通过在真实数据库上练习来提高我们的 SQL 技能。它模拟了现实生活中的工作场景，我认为这会激励你，让你更容易学习 SQL。
感谢您的阅读。如果您有任何反馈，请告诉我。
如何在 Python 中预测可变正弦曲线
数据分析
基于数学的预测 Python 中可变正弦曲线的方法。
本教程描述了如何用 Python 预测一个可变正弦曲线。首先，从 CSV 文件加载一些正弦数据。然后，通过正弦曲线对数据进行整形。之后，使用线性回归对最小和最大峰值进行建模。最后，建模的线用于计算下一个峰值。
完整的代码可以从我的 Github 库下载。
分析的数据:旅游住宿机构的到达人数摘自https://ec.europa.eu/eurostat/web/tourism/data/database
数据导入和清理
从 CSV 加载数据并清除它们
首先，我们读取 CSV 文件，我们只选择与意大利(df[df['geo'] == 'IT'])相关的数据，以数字(df[df['unit'] == 'NR'])的形式，并参考所有可用数据的总和(内部和外部到达)(df[df['c_resid'] == 'TOTAL'])。
然后我们通过函数drop()删除无用的列。注意，我们通过参数inplace=True将效果存储在原始变量df中。
import pandas as pd
df = pd.read_csv(‘data/eurostat.csv’)
df = df[df[‘geo’] == ‘IT’]
df = df[df[‘unit’] == ‘NR’]
df = df[df[‘c_resid’] == ‘TOTAL’]
df.drop([‘c_resid’, ‘unit’, ‘nace_r2’, ‘2019M11’, ‘geo’],axis=1, inplace=True)
df = df.reset_index()
df.drop([‘index’],axis=1, inplace=True)
现在我们可以纠正数据中的一些错误:一些行包含字符:，这意味着没有可用的数据。其他行包含字母b。我们改变了0中的:，并删除了字母b。
columns = df.columns[::-1]
for column in columns:
for row in range(1, len(df[column])):
if “b” in df[column][row]:
df[column] = df[column][row][:-2]
if “:” in df[column][row]:
df[column][row] = “0”
现在我们计算各列的总和，以获得每个月的总到达人数。我们将结果存储在变量y中。
y = []
for column in columns:
df[column] = df[column].astype(str).astype(int)
y.append(df[column].sum())
初步分析
绘制数据以了解数据趋势
我们绘制y来理解趋势线。我们构建辅助向量X，它包含所有的月份。0 月指的是 1990 年 1 月。为了每 5 年在图中显示 x 标签，我们构建了两个辅助变量，x_ticks和x_labels。
import matplotlib.pyplot as plt
import matplotlib
import numpy as np
X = np.arange(0, len(columns))step = 5
x_ticks = np.arange(0, len(columns)+step, step=12*step)
x_labels = []
x_labels.append(1990)
for i in range(1, len(x_tick)+1):
x_labels.append(x_labels[i-1]+step)
plt.xticks(x_ticks, x_labels)
plt.plot(X, y, color=”red”, linewidth=1)plt.grid()
plt.xlabel(‘Months’)
plt.ylabel(‘Number of arrivals’)plt.show()
我们注意到，与前几年相比，在过去的 8 年中，最大峰值有所增加。因此，我们限制了过去 8 年的分析。这意味着我们应该跳过最初的 22 年。我们将X和y重置为仅适用于最近几年。
skip = 22*12
X = X[skip:]
y = y[skip:]
数据近似值
用正弦曲线逼近数据
现在我们可以用正弦曲线来近似数据。正弦曲线的方程式为A*np.sin(omega*x+phase) + offset，其中:
- |
A|表示振幅，即函数最大值和最小值之间距离的一半 omega是 0 到 2pi 之间的循环数。周期 T 是 2pi/ωphase是水平移动offset是垂直位移，即最小峰值和振幅之和。下面是一些关于偏移的细节:https://www . ck12 . org/book/CK-12-precalculus-concepts/section/5.4/
关于正弦曲线的更多细节，可以给看看:https://mathbitsnotebook . com/代数 2/trig graphs/TG sinusoid . html。
def sinusoid(x,A,offset,omega,phase):
return A*np.sin(omega*x+phase) + offset
我们还定义了正弦曲线的初始值。我们设置周期T = 12，即一年中的月数。如果不知道周期，我们应该计算它。我们可以使用快速傅立叶变换。在这些链接中，你可以找到更多关于这方面的细节:https://stack overflow . com/questions/16716302/how-do-I-fit-a-sine-curve-to-my-data-with-pylab-and-numpy、https://www . oreilly . com/library/view/elegant-scipy/9781491922927/ch04 . html
T = 12
def get_p0(x, y):
A0 = (max(y[0:T]) — min(y[0:T]))/2
offset0 = y[0]
phase0 = 0
omega0 = 2.*np.pi/T
return [A0, offset0,omega0, phase0]
现在我们准备用正弦曲线来近似我们的数据。我们使用scipy提供的curve_fit()函数。我们绘制结果。关于curve_fit()功能的更多细节，请看https://docs . scipy . org/doc/scipy/reference/generated/scipy . optimize . curve _ fit . html。
from scipy.optimize import curve_fit
import math
param, covariance = curve_fit(sinusoid, X, y, p0=get_p0(X,y))step = 1
x_ticks = np.arange(skip, skip+len(X)+step+12, step=12*step)
x_labels = []
x_labels.append(2012)
for i in range(1, len(x_tick)+13):
x_labels.append(x_labels[i-1]+step)
plt.xticks(x_ticks, x_labels)
plt.ylabel(‘Number of arrivals’)
plt.plot(X, y, color=”red”, linewidth=1,linestyle=’dashed’)
plt.plot(X, sinusoid(X, *param), color=”blue”, linewidth=1)
plt.show()
我们用恒定值为A的正弦曲线来近似我们的数据。在我们的例子中，振幅A和offset都是可变的。这个想法是计算我们数据中所有的最大峰值和最小峰值。然后我们可以使用它们的差来计算振幅的向量，并将它们传递给sinusoid()函数。
我们定义了函数get_peaks()，它计算一个数组的峰值。我们每隔T个元素对数组进行采样，并计算每个T内的峰值。
def get_peaks(y, metrics):
n = int(math.ceil(len(y)/T))
step = 0
x_peaks = []
y_peaks = []
for i in range(0,n):
peak_index = y.index(metrics(y[step:step+T]))
x_peaks.append(peak_index + skip)
y_peaks.append(y[peak_index])
step = step+T
return [x_peaks,y_peaks]
我们计算最大和最小峰值。
min_peaks = get_peaks(y,min)
max_peaks = get_peaks(y,max)
现在我们可以计算振幅和偏移的数组。
A = []
offset = []
for i in range(0, len(min_peaks[1])):
c_a = (max_peaks[1][i] — min_peaks[1][i])/2
c_offset = min_peaks[1][i] + c_a
for j in range(0,T):
A.append(c_a)
offset.append(c_offset)
# last two months of 2019 are not available
A = A[:-2]
offset = offset[:-2]
由于A和offset是新特性，我们应该把它们作为变量添加进去。因此，我们定义了一个新变量features，它定义了我们模型的新输入特性。然后我们定义函数variable_sinusoid()，它将特性作为输入。
我们的模型返回的唯一参数是omega和phase，因此我们也用初始值omega和phase修改函数get_p0()。新功能称为variable_get_p0()。
features = [X, A, offset]
def variable_sinusoid(features,omega,phase):
x = features[0]
A = features[1]
offset = features[2]
return A*np.sin(omega*x+phase) + offsetdef variable_get_p0(x, y):
phase0 = 0
omega0 = 2.*np.pi/T
return [omega0, phase0]
我们拟合模型并绘制结果。
param, covariance = curve_fit(variable_sinusoid, features, y, p0=variable_get_p0(X,y))
plt.xticks(x_ticks, x_labels)
plt.ylabel(‘Number of arrivals’)
plt.plot(X, y, color=”red”, linewidth=1,linestyle=’dashed’)
plt.plot(X, variable_sinusoid(features, *param), color=”blue”, linewidth=1)
plt.show()
预测未来趋势线
预测可变正弦曲线的未来值
下一步包括预测下一个正弦曲线，即 2020 年的正弦曲线。为此，我们需要计算下一个最大和最小峰值。我们可以通过用两个线性回归分别逼近最大和最小峰值的向量来做到这一点。然后，我们可以计算出瞬时 2020 年 8 月)的最大峰值，作为瞬时(i-1) + pi (i-1 代表 2019 年 8 月)给出的最大线性回归的 y 值。同样，我们可以计算出 2020 年的最小峰值。
首先，我们对要传递给线性模型的峰值进行整形。然后，我们使用sklearn类LinearRegression()建立两个线性模型，每条预测线一个。之后，我们使用fit()函数拟合每个模型。
from sklearn import linear_model
# reshape x_peaks
x_min_peaks = list(map(lambda el:[el], min_peaks[0]))
x_max_peaks = list(map(lambda el:[el], max_peaks[0]))# min model
model_min = linear_model.LinearRegression()
model_min.fit(x_min_peaks,min_peaks[1])
# max model
model_max = linear_model.LinearRegression()
model_max.fit(x_max_peaks,max_peaks[1])
我们将下一个峰值添加到x_max_peaks和x_min_peaks，然后通过predict()函数预测最大和最小峰值。
x_min_peaks.append([x_min_peaks[len(x_min_peaks) -1][0] + T])
x_max_peaks.append([x_max_peaks[len(x_max_peaks) -1][0] + T])
y_pred_min = model_min.predict(x_min_peaks)
y_pred_max = model_max.predict(x_max_peaks)
我们绘制了两条预测线。
plt.xticks(x_ticks, x_labels)
plt.plot(X, y, color=”red”, linewidth=1,linestyle=’dashed’)
plt.scatter(x_min_peaks, y_pred_min, color=”green”, linewidth=1,linestyle=’dashed’)
plt.scatter(x_max_peaks, y_pred_max, color=”green”, linewidth=1,linestyle=’dashed’)
plt.ylabel(‘Number of arrivals’)
plt.grid()
plt.show()
我们计算所有周期的正弦曲线，包括 2020 年。我们构建一个变量X_pred，它包含X和 2020 年的 12 个月。
X_pred = np.array(X)
month = X_pred[len(X_pred)-1]
for i in range(0,T):
X_pred = np.append(X_pred,month)
month = month + 1
现在，我们可以更新要传递给variable_sinusoid()函数的变量features_pred。首先，我们用新值更新振幅A和offset，然后我们更新features_pred变量。
index = len(max_peaks[0])-1
c_a = (max_peaks[1][index] — min_peaks[1][index])/2
c_offset = min_peaks[1][index] + c_a
for j in range(0,T):
A.append(c_a)
offset.append(c_offset)
features_pred = [X_pred,A,offset]
最后，我们绘制图表。
plt.xticks(x_ticks, x_labels)
plt.plot(X, y, color=”red”, linewidth=1,linestyle=’dashed’)
plt.plot(X_pred, variable_sinusoid(features_pred, *param), color=”blue”, linewidth=1)
plt.grid()
plt.ylabel(‘Number of arrivals’)
plt.savefig(“data/sinusoid.png”)
plt.show()
吸取的教训
在本教程中，我介绍了一种通过可变正弦曲线来逼近正弦趋势数据的方法。然后我描述了预测下一个数据值的机制。
所描述的方法可以推广到所有类型的曲线:
- 加载和清理数据
- 绘制数据以了解趋势线
- 通过
curve_fit()功能用曲线逼近趋势线 - 绘制近似结果，并与原始数据趋势线进行比较
- 如果需要，改进近似趋势线
- 重复前两步，直到你得到一个好的近似值
- 计算(线性、多项式、…)回归以预测未来值
- 使用预测值更新近似趋势线。
如果你读到这里，对我来说，今天已经很多了。谢谢！你可以在这个链接阅读我的趋势文章。
相关文章
[## Python PyCaret 中的完整数据分析工作流
这是一个现成的教程，利用了我用过的最好的机器学习库。
towardsdatascience.com](/a-complete-data-analysis-workflow-in-python-pycaret-9a13c0fa51d4) [## Python 和 scikit 中的完整数据分析工作流程-学习
towardsdatascience.com](/a-complete-data-analysis-workflow-in-python-and-scikit-learn-9a77f7c283d3) [## Python 中探索性数据分析的可视化技术概述
关于如何在 seaborn 和 matplotlib 中为 Visual EDA 绘制最常见图形的教程
towardsdatascience.com](/an-overview-of-visual-techniques-for-exploratory-data-analysis-in-python-d35703d43faf)
在等待机器学习算法的输出时，你在做什么？
数据科学家的工作非常具有挑战性:你的知识必须涵盖从数据挖掘到数据分析，直到数据可视化。你从不停止。
然而，当你启动一个繁重的计算时，比如一个大数据集上的机器学习算法，会发生什么呢？你停下来等待结果。你可能会盯着屏幕看几个小时，希望你的剧本能完成。
不管怎么说，这不是消磨时间的最佳方式。你应该做些别的事情。你不能坐下来等待结果。
在这里继续阅读。
扫一扫
720
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
