面向数据科学的 Python 第一部分
数据科学/ Python 编程语言
近距离接触 Python
戴维·克洛德在 Unsplash 上的照片
数据科学
D 数据科学是当今谷歌上搜索次数最多的术语之一。谷歌趋势显示，自 2013 年 9 月以来，人们对“数据科学”一词的兴趣呈上升趋势。数据科学项目在所有主要大学的出现证明了这一学科新的受欢迎程度。对于门外汉来说，熟悉数据科学和数据科学家等术语是非常必要的。“数据科学”是指对数据的创建、验证和转换进行科学研究，以创造意义(定义由数据科学协会给出，这是一个由数据科学家组成的非营利性专业协会)。“数据科学家”是指使用科学方法从原始数据中解放和创造意义的专业人员。
数据科学也可以被认为是统计学与计算机科学和技术的融合。随着我们的社会变得越来越受数据驱动，计算机的处理能力逐年显著增长(以便理解大量数据)，数据成为新的石油，从而引发了数据科学的前所未有的激增。然而，通过数据科学获得有意义的结果，数据的质量与数据的数量同样重要。
图片提供:iambipin
Python 和数据科学
Python 和数据科学共享一种共生关系(某种程度上)。多年来，Python 已经成为数据科学事实上的编程语言。学习 Python 的简单和容易以及 Python 中大量人工智能(AI)包的可用性是成为数据科学的全部和最终全部的主要因素。Python 在业界的广泛使用使它成为一个显而易见的选择。
一段历史
Python 编程语言是由 Guido Van Rossum 于 20 世纪 80 年代末在荷兰的Centrum wisk unde&Informatica(CWI)创建的，此前创建一种新的编程语言( ABC 语言)将淘汰 BASIC 编程语言失败。在 2018 年 7 月 12 日选择下台之前，他还是 Python 的终身仁慈独裁者(这是一个授予拥有最终决定权的软件开发领导者的头衔)。
Van Rossum 认为他需要一个简短、独特且略带神秘的名字，所以他决定将这种语言称为 Python。
你可能会对“Python”这个名字感兴趣。编程语言为什么这么命名？当 Python 的实现开始时，吉多·范·罗苏姆也在阅读来自 20 世纪 70 年代 BBC 喜剧系列“巨蟒剧团的飞行马戏团”的出版剧本。Van Rossum 认为他需要一个简短、独特且略带神秘的名字，所以他决定将这种语言称为 Python。在他的国王日演讲中，他明确指出他的意图是向巨蟒剧团的飞行马戏团的不敬的喜剧天才致敬。他还提到，谷歌的第一个版本是用 Python 写的，因为拉里·佩奇和谢尔盖·布林认为 Python 是表达他们关于如何索引网络和组织搜索结果的原始想法的正确语言。
Python 是由一群充满激情和主人翁感的志愿者在互联网上开发的。
Python 安装
Python 可以通过从这里或者从官方网站Python.org下载 Anaconda 个人版(推荐方式)来安装。
图片提供:iambipin
双击下载的。exe 文件，并按照说明进行操作。
图片提供:iambipin
Pythonic 式的方法
Python 方式(Python 社区对遵循特定方式的代码使用的形容词)是一种非常简约的方法。
漂亮总比难看好。
显性比隐性好。
简单比复杂好。
复杂总比复杂好。
先从打印“Hello World！”并且当我们考虑在其他流行的通用语言如 C++和 Java 中做同样的事情时会理解它。
用 C++打印“Hello World ”:
#include <iostream>
#include <conio.h>
using namespace std;
int main()
{
cout<<"Hello World!";
return 0;
}
要用 Java 打印“Hello World ”:
class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
两个字的印刷“你好，世界！”可以通过一行代码在 Python 中完成。它充分说明了 Python 的简单性和极简性。
print("Hello World!")
Python 简单、强大、优雅。Python 中的编码模仿了我们说英语的方式。假设你要为学校数据库创建一个程序。考虑涉及删除学生数据的模块。记录的删除只能由具有管理权限的人员执行。如果没有它，就会出现认证错误。还必须检查班级中是否存在具有该特定 id 的学生。为了在 Python 中执行此操作，您只需编写几行代码，如下所示:
def student_delete:
"""
To delete a student from student database
"""
if not user.is_admin():
raise AuthError("You do not have sufficient privileges")
if not class.has_student(student_id):
raise ValueError("Invalid Student ID")
class.get_student(student_id).delete()
上面几行代码几乎不言自明。代码片段展示了 Python 的简单性。对于初学者来说，def 是 Python 中定义函数的关键词。在 Python 系列的后续文章中，我们肯定会详细探讨 Python 编程的本质。
在结束对 Python 编程的介绍之前，有必要熟悉一下 Tim Peters(创建了 Timsort 混合排序算法并对 Python 编程语言做出了重大贡献的软件开发人员)的“Python 之禅”。“Python 之禅”简洁地陈述了用 Python 编写计算机程序时要遵循的 19 条指导原则。您可以通过运行以下命令来查看它:
import this
然后你会看到“Python 的禅”:
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
在本系列的后续文章中，我们将深入探讨 Python 编程语言的各个方面。希望您学到了一些关于 Python 编程语言的新知识。编码快乐！！！
参考资料:
- https://en . Wikipedia . org/wiki/Python _(编程 _ 语言)
- https://gvanrossum.github.io/
- https://docs . python . org/2/FAQ/general . html #:~:text =为什么% 20 is % 20 it % 20 call % 20 python % 3F，-% C2 % B6&text = When % 20 he % 20 begin % 20 implementing % 20 python，to % 20 call % 20 language % 20 python。
- http://neopythonic . blogspot . com/2016/04/kings-day-speech . html
用于数据科学的 Python 分类机器学习指南
如何正确执行分类机器学习并对其进行评估
分类机器学习
亲爱的读者们，新年快乐。终于到了 2020 年。
随着数据的上升，
你掌握了 21 世纪最性感的技巧了吗？
它叫做——机器学习。
那是什么？你没有时间学习它，但你非常想掌握它？你找不到一篇关于机器学习的好文章，教你如何正确地执行和评估你的模型？
别担心，我会解决你所有的问题——如果我有足够的数据的话。
今天，我们将谈论所有关于机器学习的话题。 是啊，大家最爱的话题，是不是很刺激？
根据 薪级表 ，一名机器学习工程师的平均年薪为110，000 美元，不包括绩效奖金。我们都知道机器学习正在兴起，我们也知道你现在就需要学习它。
谷歌机器学习趋势
那么，机器学习到底是什么？
机器学习是人工智能(AI)的一个子集，它在机器中引入了“学习”的能力。把它想象成机器能够在它们的人工大脑中开发出一个模式，给定你提供给它的数据。
图片来自维基媒体
传统上，我们通过给机器规则来给它们编程做一些事情，比如一个 if-else 语句。现在，我们让机器通过向它们提供数据来发现这些规则。这里有一个形象化的例子可以帮助你更好地理解它。
机器能够通过训练过程发现这些规则，在训练过程中，机器尝试不同的规则，并评估每个规则与我们的数据的拟合程度。发现规则后，我们现在可以说机器根据我们的数据造出了一个模型。
该过程的一个例子是:
- 将猫的图像传入机器，并贴上“猫”的标签
- 传入女孩的数据和她们的习惯，同时给她们贴上“女孩”的标签
- 传入每个员工的工资以及他们的职位和资格
在这个过程之后，机器将能够预测:
- 如果图像是猫或其他动物
- 如果是女孩或男孩，根据这个人的习惯
- 具有某个职位和资格的员工的工资
机器学习有多种形式。经常提到的有监督、无监督和强化学习。定义您将处理哪种形式的机器学习的主要因素将是您的数据集，或数据。
如果你有一组输入和输出，大多数时候它会被归类为监督机器学习。为了简单起见，我们将在本文中只讨论监督学习来帮助您入门。
分类和回归
监督机器学习处理两个主要问题，
分类和回归。
如果你注意了，我上面展示的例子是关于—
- 女孩还是男孩——分类
- 员工工资-回归
相当直接。
分类通常有离散输出，而
回归有连续输出。
先决条件
首先，我们需要知道您将如何收集您的数据。
今天，大多数现实世界的企业都使用机器学习来优化他们的产品/服务。
- 当您停止使用某项服务一段时间后，您可能会收到一封电子邮件，向您提供折扣/奖励以继续使用该服务。
- 当你浏览 Youtube/网飞时，你会得到与你的兴趣相符的推荐，这会让你在这个平台上呆得更久。
- 当你的照片被发布到脸书上时，你会自动被平台识别并被标记。
如果你在这些组织中的一个工作，他们已经建立了适当的数据仓库，包含了大部分的数据。然后，您可以在大多数情况下通过使用 SQL 来提取这些数据。因此，您首先需要的是 SQL 。
列表上的下一个可能是 Python ，带有特定的库。
Pandas 将是 Python 中用来操作数据的主库，所以那应该是你掌握的第一个库。
10 分钟内完成数据探索指南
towardsdatascience.com](/python-for-data-science-basics-of-pandas-5f8d9680617e)
之后，我们将通过本文中的来可视化**我们的大量数据和发现。没有它，没有人能真正理解我们在做什么。
我已经写了多篇关于的文章，一定要看看它们来刷新你的记忆。**
**** [## 面向数据科学的 python——Plotly 数据可视化指南
现在是 2020 年，是时候停止使用 Matplotlib 和 Seaborn 了
towardsdatascience.com](/python-for-data-science-a-guide-to-data-visualization-with-plotly-969a59997d0c) [## 用于数据科学的 Python 使用 Plotly 进行数据可视化的高级指南
如何在 Plotly 中添加和自定义滑块、下拉菜单和按钮
towardsdatascience.com](/python-for-data-science-advance-guide-to-data-visualization-with-plotly-8dbeaedb9724)
继续，知道如何正确地探索你的数据也是很好的。
拿到数据集后，很多数据从业者往往不知道该怎么处理。这种情况经常导致我们都想避免的优化较差的机器学习模型。
** [## 用于数据科学的 Python 在执行机器学习之前要做什么？
不要沉迷于机器学习模型，先了解你的数据。
towardsdatascience.com](/python-for-data-science-what-to-do-before-performing-machine-learning-a30f62465632)
从 Plotly 到熊猫再到机器学习。我掩护你。既然已经出来了，是时候开始了。
进口
像往常一样，我们将与 Jupyter 笔记本 一起工作。
#all plotly
from plotly.offline import init_notebook_mode,iplot
import plotly.graph_objects as go
import cufflinks as cf
init_notebook_mode(connected=True)#others
import pandas as pd
import numpy as np
导入数据集
在本文中，我们将使用一个 电信客户流失数据集 。
df = pd.read_csv(filepath)
机器学习的数据预处理
在这个阶段，我们将把数据预处理成机器可读的格式。请记住，机器实际上并不理解文本，因为它们只是将文本作为输入。例如，机器不理解文本“男性”和“女性”之间的差异**。因此，在我们通过训练过程之前，我们需要正确地处理我们的分类和数字数据。**
分类数据
将分类数据转换成可理解输入的最常用方法是为每个类别创建虚拟变量**。例如，我们的合同栏中有 3 种类型的合同，即“逐月”、“一年”和“两年”。然后，合同列被转换为 3 列，每种类型的合同对应一个真或假指示器。这里有一幅图可以帮忙。**
分类数据预处理
我们可以通过熊猫的 get_dummies 函数很容易地做到这一点。
#Creating Dummy Variables for Categorical Columns
df = pd.get_dummies(data = df,columns = cat_cols )
我们可以看到分类列已经被处理过了。然而，也有布尔列只包含两个类别，通常是或否。我们可以使用以下公式将这些值编码为 1 和 0:
from sklearn.preprocessing import LabelEncoder
#Encoding bool_cols
le = LabelEncoder()
for i in bool_cols :
df[i] = le.fit_transform(df[i])
现在所有的分类和布尔列都完成了。
我们只剩下—
数字列
数字列的预处理包括缩放**，使得一个量的变化等于另一个量的变化。机器需要理解，仅仅因为一些列(如“总费用”)有很大的值，并不意味着它在预测结果方面起很大作用。为了实现这一点，我们将所有的数字列放在同一个标度中，这样它们就不会被另一个支配。**
from sklearn.preprocessing import StandardScaler
#Scaling Numerical columns
std = StandardScaler()
scaled = std.fit_transform(df[num_cols])
scaled = pd.DataFrame(scaled,columns=num_cols)df.drop(columns = num_cols,axis = 1, inplace= True)
df = df.merge(scaled,left_index=True,right_index=True,how = "left")
分割训练和测试
完美。现在我们的数据已经被完美地缩放和分类了。我们可以将它们分成我们的训练集和测试集。
训练集是我们传递到训练过程中的数据，而测试数据用于评估我们的模型。
#splitting train and test data
train,test = train_test_split(df,test_size = .25 ,random_state = 111)#defining our features and metric
cols = [i for i in df.columns if i not in Id_col + metric_col]
train_X = train[cols]
train_Y = train[metric_col]
test_X = test[cols]
test_Y = test[metric_col]
取样操作
如今，来自现实生活情况的数据经常导致对每个潜在输出的不平衡数量的观察。
通过数据探索，我们做的第一件事是找出流失客户和非流失客户的数量。结果是—
如您所见，非流失客户的数量明显高于流失客户的数量**。不需要太多的细节，这将给我们的模型带来一个问题，因为机器正在获得更多关于非流失客户的信息，并且可能将流失客户误认为非流失客户。因此，这将降低预测客户流失的准确性。**
换句话说，我们的模型将擅长预测客户是否会留在**，但在预测客户是否会流失时表现不佳。根据业务需求，这显然与我们试图实现的目标相矛盾。我们希望尽可能准确地预测客户流失情况，以便抓住所有客户，并采取额外的商业行动来说服他们留下来。例如，如果我们知道客户即将流失，就发送折扣代码。**
过采样
也就是说，我们可以通过
过采样来最小化这个问题的影响。过采样是人为增加数据集中某一类的观察次数的方法。通常，我们更喜欢平衡每个类的观察数量，这意味着我们应该有 50%的流失观察和 50%的非流失观察。
重击
我们将使用的方法是 SMOTE，代表综合少数过采样技术。在不涉及太多细节的情况下，SMOTE 人为地创造了新的观察结果，而不仅仅是现有少数民族案例的副本。相反，该算法通过涉及向量、随机数和每个样本的最近邻居来创建新的观察值。对我们来说，最主要的收获是，现在公平地创造了更多对流失客户的观察。
这里是为了便于理解，对 SMOTE 算法的补充阅读。
from imblearn.over_sampling import SMOTEcols = [i for i in df.columns if i not in Id_col+metric_col]
smote_X = df[cols]
smote_Y = df[metric_col]#Split train and test data
smote_train_X,smote_test_X,smote_train_Y,smote_test_Y = train_test_split(smote_X,smote_Y, test_size = .25 , random_state = 111)#oversampling minority class using smote
os = SMOTE(random_state = 0)
os_smote_X,os_smote_Y = os.fit_sample(smote_train_X.to_numpy(),smote_train_Y.to_numpy())
os_smote_X = pd.DataFrame(data = os_smote_X,columns=cols)
os_smote_Y = pd.DataFrame(data = os_smote_Y,columns=metric_col)
现在，我们有 2 列车组和 2 测试组。
其中一个是原始数据，另一个应用了 SMOTE。
我们稍后会比较他们的表现。
特征选择
现在我们有了一组平衡的数据。
我们如何知道包括和不包括的特征？
我们不应该假设所有的特征在预测结果时都起着重要的作用。其中有些可能无关紧要，也可能无关紧要。我们可以在相关图中清楚地观察到这一点。
#correlation
correlation = df.corr()
#tick labels
matrix_cols = correlation.columns.tolist()
#convert to array
corr_array = np.array(correlation)#Plotting
trace = go.Heatmap(z = corr_array,
x = matrix_cols,
y = matrix_cols,
colorscale = "Magma",
colorbar = dict(title = "Pearson Correlation coefficient",
titleside = "right"
) ,
)layout = go.Layout(dict(title = "Correlation Matrix for variables",
autosize = False,
height = 720,
width = 800,
margin = dict(r = 0 ,l = 210,
t = 25,b = 210,
),
yaxis = dict(tickfont = dict(size = 9)),
xaxis = dict(tickfont = dict(size = 9))
)
)data = [trace]
fig = go.Figure(data=data,layout=layout)
iplot(fig)
相关图表
我们可以从关联热图中观察到，不同的特征对客户流失有不同的影响。过多特征的结果是噪声，这会降低我们模型的性能。因此，我们如何确定哪些特征是重要的？— 功能选择
特征选择是机器学习中的核心技术之一，它将提高性能，缩短训练时间，并提高模型的简单性。有多种特征选择算法，我们今天将使用的一种被称为—
递归特征消除。
递归特征消除(RFE)拟合模型并消除最弱的特征，直到达到指定的特征数量。下面是对它的详细解释:
如前所述，递归特征消除(RFE，Guyon 等人( 2002 ))基本上是预测器的向后选择。该技术首先在整个预测因子集上建立一个模型，并计算每个预测因子的重要性分数。然后移除最不重要的预测值，重新构建模型，并再次计算重要性分数。在实践中，分析师指定要评估的预测值子集的数量以及每个子集的大小。因此，子集大小是 RFE 的一个调整参数。优化性能标准的子集大小用于基于重要性排名选择预测器。然后，最佳子集用于训练最终模型。[4]
from sklearn.linear_model import LogisticRegressionfrom sklearn.feature_selection import RFE
from sklearn.linear_model import LogisticRegressionlog = LogisticRegression()rfe = RFE(log,10)
rfe = rfe.fit(os_smote_X,os_smote_Y.values.ravel())#identified columns Recursive Feature Elimination
idc_rfe = pd.DataFrame({"rfe_support" :rfe.support_,
"columns" : [i for i in df.columns if i not in Id_col + metric_col],
"ranking" : rfe.ranking_,
})
cols = idc_rfe[idc_rfe["rfe_support"] == True]["columns"].tolist()
在这段代码中，我们选择了 10 个最好的特性来包含在我们的逻辑回归模型中。然后我们可以画出 RFE 的排名。
import plotly.figure_factory as ff
tab_rk = ff.create_table(idc_rfe)
iplot(tab_rk)
这张表显示了 RFE 选择的特性，以及它们各自的排名，这样你就可以衡量某个特性的重要性。
我们现在可以分离数据集了。
#separating train and test data SMOTE
train_rf_X_smote = os_smote_X[cols]
train_rf_Y_smote = os_smote_Y
test_rf_X_smote = test[cols]
test_rf_Y_smote = test[metric_col]#separating train and test data Original
train_rf_X = train_X[cols]
train_rf_Y = train_Y
test_rf_X = test_X[cols]
test_rf_Y = test_Y
在这个阶段，我们有 2 训练集和 2 测试集，其中所有特征都被递归消除。其中一个是原始数据，另一个应用了 SMOTE。
培训模式
现在到了我们训练模型的实际阶段。
有多种算法用于训练分类问题。
我们无法判断哪种算法最适合我们的数据，因此我们通常使用多种算法进行训练，并根据精心选择的标准比较它们的性能。今天，我们将只关注逻辑回归以及它与我们数据的吻合程度。
维基媒体的 Sigmoid 函数
逻辑回归是最常用的机器学习算法之一，用来预测二进制类，在这种情况下流失而不流失。它的工作原理是将基于 Sigmoid 函数的 0 和 1 之间的输出概率附加到每个输入。基于默认为 0.5 的阈值，高于该阈值的将被归类为 1 (流失)，低于该阈值的将被归类为 0 (非流失)。
由 ML-Cheatsheet 决定边界
决策阈值
例如，如果我们的阈值是 0.5，而我们对一组特征的预测概率是 0.7，那么在我们的例子中，我们会将这个观察结果归类为变动**。**
理解了这一点，让我们训练我们的数据。
#training for dataset without smote
logit_ori_rfe = LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
intercept_scaling=1, max_iter=100, multi_class='ovr', n_jobs=1,
penalty='l2', random_state=None, solver='liblinear', tol=0.0001,
verbose=0, warm_start=False)
logit_ori_rfe.fit(train_rf_X,train_rf_Y)#training for dataset with smote
logit_smote_rfe = LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
intercept_scaling=1, max_iter=100, multi_class='ovr', n_jobs=1,
penalty='l2', random_state=None, solver='liblinear', tol=0.0001,
verbose=0, warm_start=False)
logit_smote_rfe.fit(train_rf_X_smote,train_rf_Y_smote)
差不多就是这样，我们的模型已经训练好了。如你所见，训练一个模特并没有你想象的那么复杂。
大多数时候，将数据转换成“好的”格式进行训练，以及评估您的模型，这是非常耗时的部分。
评估您的模型
我们有两种型号。一个用 SMOTE 数据集训练，一个用原始数据集训练。我们可以开始使用这些模型进行预测，但我们想首先评估这些模型的准确程度。
为了评估模型，我们需要考虑一些标准。
对于分类，我们用来评估模型的几个常用指标是
- 准确(性)
- 精确
- 召回
- f1-分数
- ROC 曲线
让我解释一下每一个的意思。
精确度和召回由维基媒体
在讨论召回率和精确度之前，我们需要了解什么是误报、漏报以及它们的对应情况。
这可以通过左边的图表更好地解释，想象完整的图表是我们的数据集，圆圈是我们模型的预测。图的左边是实际的正值(1)，图的右边是实际的负值(0)。
看左边的圆圈，圆圈内的所有点都被我们的模型预测为正，而圆圈外的所有点都被我们的模型预测为负。我们还知道，在图的左边，圆圈外的所有点都是正的。因此，它被错误地预测，指示一个假阴性。图表左侧圆圈中的所有点都被正确预测，表明真阳性**。**
反之亦然适用于图的右侧。
精确度和召回率
维基百科的精确度和召回率
精确度和召回率使我们对模型有了更深入的理解。
精度定义为相关结果的百分比，
召回定义为正确分类的相关结果的百分比。
在不涉及太多细节的情况下，我们模型中的精度指的是被正确分类的预测流失客户的百分比。
召回措施为正确分类的实际流失客户的百分比。
F1 分数
在许多情况下，我们可以根据您试图解决的问题来优先考虑精度或回忆。在我们的案例中，我们肯定希望优先考虑** 尽可能准确地预测实际客户流失，这样我们就可以说服他们留下来。**
在一般情况下，有一个指标可以协调精确度和召回率，这就是 F1 分数。总体目标是最大化 F1 分数，使你的模型更好。
F1 分数公式
ROC 曲线和 AUC
在调整多个变量以最大化我们的精确度、召回率和 F1 分数之后，我们还可以调整模型的阈值。
例如，阈值默认为 0.5，高于该值的任何输出概率都将被归类为 1。我们可以将阈值更改为更低/更高的值，以进一步增加我们的首选指标。
为了形象化这种变化，我们可以画出每个阈值对假阳性率和真阳性率的影响。曲线看起来会像这样。
受试者工作特征曲线
再说一次，不要涉及太多的细节，你的模型越好，曲线(蓝色)就越靠近图的左上角。相反，一个在分类方面做得很差的模型会向直线(红色)收敛，这不比随机猜测好。
使用 ROC 曲线，我们可以正确地确定一个模型是否优于另一个模型。我们也可以根据我们是否应该最大化真阳性率**，或者最小化假阳性率来选择我们的分类阈值。在我们的情况下，我们应该以最大化真实阳性率为目标。因此，这也将增加我们的召回指标。**
准确(性)
准确性是衡量模型性能的最基本的标准。它基本上是根据测试集正确预测的输出的百分比。
因此，我们确实应该考虑将召回**、准确性和 F1 得分作为这个特定模型的重要指标。**
让我们开始吧。
#perfoming evaluation for original dataset
predictions = logit_ori_rfe.predict(test_rf_X)
probabilities = logit_ori_rfe.predict_proba(test_rf_X)print(classification_report(test_rf_Y,predictions))#confusion matrix
conf_matrix = confusion_matrix(test_rf_Y,predictions)
conf_matrix#roc_auc_score
model_roc_auc = roc_auc_score(test_rf_Y,predictions)
print ("Area under curve : ",model_roc_auc,"\n")
fpr,tpr,thresholds = roc_curve(test_rf_Y,probabilities[:,1])
评估指标
从我们在原始数据集上训练的模型来看，总体准确率相当高，为 81% 。然而，我们可以看到代表流失客户的类别 1** 的所有指标都相当低。**
- 精度为 69%
- 召回率为 56%
- F1 为 62%
由于观察值数量的不平衡，我们得到了一个相当高的加权平均值，因为与类别 1 相比，类别 0 的观察值要多得多。这是一个危险信号的迹象，因为我们的首要任务是能够准确预测 1 级。
#plot roc curve
trace2 = go.Scatter(x = fpr,y = tpr,
name = "Roc : " + str(model_roc_auc),
line = dict(color = ('rgb(22, 96, 167)'),width = 2))
trace3 = go.Scatter(x = [0,1],y=[0,1],
line = dict(color = ('rgb(205, 12, 24)'),width = 2,
dash = 'dot'))data = [trace2,trace3]layout = go.Layout(dict(title = "Receiver operating characteristic",
autosize = False,
height = 700,width = 800,
plot_bgcolor = 'rgba(240,240,240, 0.95)',
paper_bgcolor = 'rgba(240,240,240, 0.95)',
margin = dict(b = 195),
xaxis = dict(title = "false positive rate"),
yaxis = dict(title = "true positive rate"),
)
)#defining figure and plotting
fig = go.Figure(data,layout=layout)
iplot(fig)
受试者工作特征曲线
从 ROC 曲线上我们看到 AUC 是 73%，后面可以对比其他模型。
visualizer = DiscriminationThreshold(logit_ori_rfe)
visualizer.fit(train_X,train_Y)
visualizer.poof()
阈值图
阈值图对于我们确定阈值也很有用。正如我们所知，我们正试图最大化** 召回，同时不牺牲太多其他指标。阈值图帮助我们准确地做到这一点。
看起来接近 0.3 的阈值将允许我们最大限度地提高召回率，同时保持其他指标不变。**
这就是我们迄今为止对第一个模型的理解，让我们评估一下由 SMOTE 数据集训练的模型。
#perfoming evaluation for original dataset
predictions = logit_smote_rfe.predict(train_rf_X_smote)
probabilities = logit_smote_rfe.predict_proba(train_rf_X_smote)print(classification_report(train_rf_Y_smote,predictions))#confusion matrix
conf_matrix = confusion_matrix(train_rf_Y_smote,predictions)
conf_matrix#roc_auc_score
model_roc_auc = roc_auc_score(train_rf_Y_smote,predictions)
print ("Area under curve : ",model_roc_auc,"\n")
fpr,tpr,thresholds = roc_curve(train_rf_Y_smote,probabilities[:,1])
评估指标
很快，您可以观察到第 1 类(流失客户)的所有指标都显著增加。不利的一面是，整体精度会略有下降。
- 精度为 75%
- 召回率为 83%(几乎增加了 30%)
- F1 为 78%
作为一名专业的数据科学家，您应该在一天中的任何时候推荐这个模型而不是第一个模型。因为当务之急是准确预测的客户流失，所以你必须明白这个模型比之前的模型做得好得多，即使整体准确性略有下降。这就是真正的数据科学家与平庸的数据科学家的区别。
****#plot roc curve
trace2 = go.Scatter(x = fpr,y = tpr,
name = "Roc : " + str(model_roc_auc),
line = dict(color = ('rgb(22, 96, 167)'),width = 2))
trace3 = go.Scatter(x = [0,1],y=[0,1],
line = dict(color = ('rgb(205, 12, 24)'),width = 2,
dash = 'dot'))data = [trace2,trace3]layout = go.Layout(dict(title = "Receiver operating characteristic",
autosize = False,
height = 700,width = 800,
plot_bgcolor = 'rgba(240,240,240, 0.95)',
paper_bgcolor = 'rgba(240,240,240, 0.95)',
margin = dict(b = 195),
xaxis = dict(title = "false positive rate"),
yaxis = dict(title = "true positive rate"),
)
)#defining figure and plotting
fig = go.Figure(data,layout=layout)
iplot(fig)****
受试者工作特征曲线
从 ROC 曲线中，我们观察到 AUC 约为 78%,比我们之前的模型高出约 5%。这表明我们的 SMOTE 模型优于以前的模型。
****visualizer = DiscriminationThreshold(logit_smote_rfe)
visualizer.fit(train_rf_X_smote,train_rf_Y_smote)
visualizer.poof()****
阈值图
阈值图也表明了我们当前模型的性能优势。请注意，我们如何在这里将阈值调得更高，以获得相对较高的召回率、精确度和准确度。
当前模型，阈值=0.4:
- 约 90%的召回率
- F1 分数约为 80%
- 大约 70%的精度
以前的模型，阈值= 0.3:
- 约 80%的召回率
- F1 分数约为 60%
- 大约 50%的精度
请注意，我们希望避免设置太低的阈值，否则我们会以过多的误报而告终。看起来我们有一个明显的赢家。****
总的来说，我们用两个不同的数据集使用逻辑回归训练了两个模型，一个使用 SMOTE 采样，一个不使用。基于几个标准，SMOTE 模型在预测流失客户方面表现明显更好。现在，您可以使用该模型来预测未来的客户流失。
结论
做得好，我知道这是一个漫长的，但它是值得的。
机器学习是一个复杂的过程，有许多因素决定你的模型的性能，从而决定你的技能组合。
在本文中，您已经了解到:
- 什么是机器学习
- 数据预处理(数值和分类)
- 取样操作
- 特征选择
- 培训模型
- 评估模型
这些技术只是机器学习的开始，
我们还有更多的内容要介绍。
在你走之前
我们的数据之旅还没有结束。随着数据行业人才的缺乏，用机器学习的适当知识来教育自己将使你在获得数据角色方面具有优势。请继续关注，我将在下一篇文章中讨论如何为您的数据集选择正确的模型，以及更多关于数据行业的故事、指南和经验。与此同时，请随意查看我的其他文章，以暂时满足您对数据的渴望。
一如既往，我引用一句话作为结束。
在机器学习和人工智能领域，我们需要迎头赶上。——克劳斯·弗罗利希
订阅我的时事通讯，保持联系。
也可以通过 我的链接 注册中等会员来支持我。你将能够从我和其他不可思议的作家那里读到无限量的故事！
我正在撰写更多关于数据行业的故事、文章和指南。你绝对可以期待更多这样的帖子。与此同时，可以随时查看我的其他 文章 来暂时填补你对数据的饥渴。
感谢 的阅读！如果你想与我取得联系，请随时联系我在 nickmydata@gmail.com 或我的 LinkedIn 个人资料 。也可以在我的Github中查看之前写的代码。****
面向数据科学的 python——Plotly Dash 交互式可视化指南
构建您的第一个 web 应用程序！
卢克·切瑟在 Unsplash 上的照片
问候读者，
如果你像我一样，你喜欢数据。当数据被恰当地呈现时，它可以讲述很多故事。
我们生活在一个人们依赖数据进行商业决策的时代，这就是为什么专业地展示数据会让你领先于他人。
想象给了你一些你不知道的问题的答案。
—本·施奈德曼
我们可以通过使用惊人的可视化技术来实现这一点。我们已经讨论过如何利用我们目前在 Python 中拥有的强大库。
[## 面向数据科学的 python——Plotly 数据可视化指南
现在是 2020 年，是时候停止使用 Matplotlib 和 Seaborn 了
towardsdatascience.com](/python-for-data-science-a-guide-to-data-visualization-with-plotly-969a59997d0c) [## 用于数据科学的 Python 使用 Plotly 进行数据可视化的高级指南
如何在 Plotly 中添加和自定义滑块、下拉菜单和按钮
towardsdatascience.com](/python-for-data-science-advance-guide-to-data-visualization-with-plotly-8dbeaedb9724)
在这篇文章中，我们将会更进一步。我们将讨论如何使用 Python 中的 Plotly Dash 构建一个交互式仪表盘。仪表板甚至可以作为 web 应用程序托管。
破折号
纽约石油和天然气由 Dash 应用程序库
达什是这个街区新的性感男孩。
这是一个 Python 框架，允许你使用 Flask、Plotly.js 和 React.js 创建惊人的 web 应用。Dash 在构建具有高度定制用户界面的数据可视化应用程序方面效率极高，无需了解任何 HTML、CSS 或 Javascript。
基本上，如果你已经掌握了 Python，它会很快，很漂亮，也很容易学。
Dash 消除了所有需要了解 web 开发的担忧，包括部署应用程序的头痛问题。它易于维护，跨平台，并且可以随时移动。
现在你可以只用纯 python 来构建你的移动响应网络应用。
但是说够了
我开始听起来像 Dash 的推销员了。
spiro 的 gif 图片
同样令人欣慰的是，近年来对 Plotly Dash 的需求正在增加。以下是 Plotly Dash 在过去 5 年的谷歌趋势中的结果。
现在那已经不碍事了。让我们开始吧。
先决条件
Dash 可视化基于 Plotly。
因此，请确保你在继续阅读这个提前指南之前，已经对和的基础知识有了扎实的理解。你可以在这里参考我写的关于 Plotly 的 基础的文章 。
为了和 Plotly 一起工作，你也应该掌握熊猫。
真巧。我碰巧也写了一本熊猫指南。
如需刷新记忆，请过一遍。
10 分钟内完成数据探索指南
towardsdatascience.com](/python-for-data-science-basics-of-pandas-5f8d9680617e)
进口
装置
pip install dash
使用 Jupyter 笔记本电脑…
import dash
import dash_core_components as dcc
import dash_html_components as html
import plotly.graph_objs as go
import pandas as pd
import numpy as np
from dash.dependencies import Input, Output
df = pd.read_csv('mpg.csv')
作者图片
第一部分。布局
作者图片
Dash 框架分为两部分。第一部分是应用程序的布局，它定义了应用程序的外观和感觉。这涉及到你应用程序上所有东西的风格、定位和大小。
Dash 使用组件来定义布局。
- dash_core_components —用于交互用户界面的组件。这些组件由 Dash 团队开发和维护，包括像搜索栏、范围滑块和任何你能想到的用于交互式图形体验的东西。
- dash_html_components —表示 HTML 、 CSS 和 Javascript 代码的组件。你可以使用这个组件来声明标签，比如 div 和 img
和，就像你开发一个网站一样。
让我们建立一个简单的“Hello World”布局来热身。
#initiating the app
app = dash.Dash()#defining the layout
app.layout = html.Div(children=[
html.H1(children='Hello World!')
])#running the app
if __name__ == '__main__':
app.run_server()
在这个应用程序中，我们简单地定义了一个 H1 HTML 标签为“Hello World”。
不管你在哪里运行代码，你都应该像这样。
作者图片
点击链接访问您的应用程序。
作者图片
这就是你的第一个“Hello World”应用程序。这很酷，但让我们在应用程序中展示一个真实的图表。
#initiating the app
app = dash.Dash()#defining the layout
app.layout = html.Div(children=[
html.H1(children='Hello World!')
html.Div(children='Dash: A web application framework for Python.'),dcc.Graph(
id='graphid',
figure={
'data': [
{'x': [1, 2, 3], 'y': [4, 1, 2], 'type': 'bar', 'name': 'Cats'},
{'x': [1, 2, 3], 'y': [2, 4, 5], 'type': 'bar', 'name': 'Dogs'},
],
'layout': {
'title': 'Cats vs Dogs'
}
}
)
])#running the app
if __name__ == '__main__':
app.run_server()
作者图片
在这段代码中，我们引入了 Div 标签(最常用的标签之一)和 dcc。图形组件。
dcc。图形组件
图形组件用于显示一个图形图形。图形参数用来表示 **go。图，**你可以在这里刷新一下关于它的记忆。
fig = go.Figure(data = data,layout = layout)#**data can be any type of plotly graphs (pie chart,scatter, etc)**
基本上，您可以通过 dcc 传递任何类型的 Plotly 图。要在您的应用程序上显示的图形组件。然后，您可以进一步定制Plotly 和 Dash 中该图形的样式。
现在让我们为从 Github 导入的数据做一个布局。
app = dash.Dash()
df['year'] = random.randint(-4,5,len(df))*0.10 + df['model_year']app.layout = html.Div([
html.Div([
dcc.Graph(id='mpg-scatter',
figure={
'data':[go.Scatter(
x=df['year']+1900,
y=df['mpg'],
text=df['name'],
mode='markers'
)],
'layout':go.Layout(
title='MPG vs Model Year',
xaxis={'title':'Model Year'},
yaxis={'title':'MPG'},
hovermode='closest'
)}
)
],style={'width':'50%','display':'inline-block'}),
])if __name__ == '__main__':
app.run_server()
作者图片
在这个应用程序中，我们只是将数据集中的车型年的每加仑**英里数可视化。**另外，随着车型年的增加，我们可以清楚地看到 MPG 略有增加。
使用 style 参数，我们可以声明我们希望图表在仪表板中的外观。通过检查web 应用程序的元素，您可以进一步深入到样式中。
作者图片
我们可以看到这个内部 div 的宽度是其父 div 的一半。这是因为我们在代码中声明了以下内容。
style={'width':'50%'}
我认为到目前为止，在 Dash we 中制作一个简单的仪表板是非常简单的。
- 像你在绘图时那样绘制图表
- 将图表作为 dcc 插入。图仪表板中的部件
- 根据我们的需要调整风格
- 运行应用程序
第二部分。互动回访
这就是有趣的地方。
在声明了我们的基本布局之后，Dash 允许我们在应用程序中添加复杂的交互。这个组件也将允许我们实时更新我们的数据。
- 当用户悬停在您的图表上时，进行某些更改
- 当用户在搜索栏中键入内容时更新可视化效果
- 在用户刷新时或在实时更新数据
是的，你没听错。
如果需要，仪表板将能够在中实时更新自身，但稍后会详细介绍。让我们来讨论如何使用回调来更新特定用户操作的数据。
回调函数
我们通过在布局之后定义回调函数来实现这一点。回调函数，像其他函数一样，有—
- 一个输入
- 一个输出
- 如何处理输入
[@app](http://twitter.com/app).callback(Output('<component-id>','<what to update>'),
[Input('<component-id>','<what to take in as Input>')])
def callback_graph(<random name for inputs>):
x = do something with x
return x
使用我们在 Dash 中声明的组件 id，我们能够精确定位我们想要什么作为我们函数的输入，以及更新什么。
Hoverdata
例如，我们将使用包含在 dcc 中的一个属性。图形组件默认为，悬停数据。它会返回一个 JSON 字符串，其中包含您所悬停的数据的相关信息。让我展示给你看。
html.Div([
dcc.Markdown(id='hoverdata-text')
])[@app](http://twitter.com/app).callback(Output('hoverdata-text','children'),
[Input('mpg-scatter','hoverData')])
def callback_stats(hoverData):
return str(hoverData)#children is the default property that a component will display
作者图片
在这一节中，我们在图表下面添加了一个 Div 来显示我们所悬停的内容。如您所见，当我们将鼠标悬停在图中的不同点上时，Div 的内容会立即更新。我们通过以下方式实现这一目标—
- 将 HoverData 作为输入
- 将 Div 声明为输出
- 将 HoverData 显示为纯文本
*额外注意:HoverData 中的 pointIndex 代表当前引用数据的 DataFrame 的索引。这在以后会很有用。
也就是说，我们可以利用接收到的输入做各种事情。天空才是极限。
回去工作
让我们展示一些关于我们导入的数据集的有趣内容。
对于我们的第一款网络应用，我们希望展示每个数据点—
- 汽车型号名称
- 加速
- 达到 0 到 60 英里/小时所需的时间
作者图片
通过利用 HoverData 中的数据，我们可以参考我们的 pandas dataframe，mpg.csv 中的实际数据。然后，我们可以基于它进行计算，并显示我们想要显示的各种指标。
我希望您现在意识到了，Dash 框架有多强大。
结论
恭喜你，
您已经掌握了 Plotly Dash 的基本概念。
在这篇文章中，你学到了—
1。仪表板—布局
2。破折号—回调
这两者对于构建你的第一个 web 应用程序都是必不可少的。
现在去吧，数据从业者，
去造一个你感兴趣的东西，展示给全世界。
如果你遇到困难，请随时联系我。你可以在下面找到我的信息。
在你走之前
我们的数据之旅还没有结束。我正在撰写更多关于数据行业的故事、文章和指南。你绝对可以期待更多这样的帖子。与此同时，请随意查看我的其他文章来暂时填补您对数据的渴望。
像往常一样，我引用一句话作为结束。
学习如何做数据科学就像学习滑雪一样。你必须做这件事。 — 克劳迪娅·珀里奇 ，首席科学家，d stilley
订阅我的简讯，保持联系。
也可以通过 我的链接 注册一个中等会员来支持我。你将能够从我和其他不可思议的作家那里读到无限量的故事！
我正在撰写更多关于数据行业的故事、文章和指南。你绝对可以期待更多这样的帖子。与此同时，可以随时查看我的其他 文章 来暂时填补你对数据的饥渴。
感谢 的阅读！如果你想和我取得联系，请随时通过 nickmydata@gmail.com 联系我或者我的 LinkedIn 个人资料 。也可以在我的Github中查看之前写的代码。
用于数据科学的 python-Plotly Dash 交互式可视化高级指南
构建您的第一个实时仪表板！不，真的！
斯蒂芬·道森在 Unsplash 上拍摄的照片
问候数据从业者，
我想你已经意识到对懂得如何交流数据的人的需求在增加。这正是我们应该在数据科学行业中不断寻求改进、学习更多知识和提高技能的原因。
即使围绕机器学习大肆宣传，**数据可视化也没有失去其重要性。**在规划任何机器学习之前，通常需要进行探索性数据分析。
大型科技公司经常需要交流他们拥有的数据。
我们是执行的人。
一个很好的例子就是谷歌和他们已知的谷歌趋势。
作者截图
因此，构建干净的和漂亮的T21 可视化是一项有价值的技能，它绝对会让你脱颖而出。****
破折号
Dash 应用程序库的临床分析仪表板
你听说过神出鬼没吗？
达什是这个街区的新成员。我在这里写了一下。
[## 面向数据科学的 python——Plotly Dash 交互式可视化指南
构建您的第一个 web 应用程序！
towardsdatascience.com](/python-for-data-science-a-guide-to-plotly-dash-interactive-visualizations-66a5a6ecd93e)
基本上， Dash 是新的 Python 库，它允许你在不需要了解任何 HTML、CSS 或 Javascript 的情况下，构建具有高度定制化用户界面的惊人的数据可视化应用。
它消除了部署应用程序的麻烦，使其移动响应和易于维护。
但是你已经知道我在想什么了。
gif 由 thelonelyisland
你不是为这个来的，你想知道更多。
在本文中，我们将讨论如何将更多的定制添加到 Dash web 应用程序中。我们还将深入探讨如何在没有任何交互的情况下实时更新仪表盘，。
先决条件
Dash 可视化基于 Plotly。理解构建简单的 Plotly 图的基本原理很重要。我在这里 **，**写了构建基本的 Plotly 图 ，涵盖了构建任何类型的图时需要理解的概念。
[## 面向数据科学的 python——Plotly 数据可视化指南
现在是 2020 年，是时候停止使用 Matplotlib 和 Seaborn 了
towardsdatascience.com](/python-for-data-science-a-guide-to-data-visualization-with-plotly-969a59997d0c)
为了使用 Plotly，您需要使用 Pandas 对您的数据执行一些软转换。
我掩护你。我碰巧也写了一本熊猫指南。
如果你需要刷新关于熊猫的记忆，请去翻阅一下。
10 分钟内完成数据探索指南
towardsdatascience.com](/python-for-data-science-basics-of-pandas-5f8d9680617e)
进口
装置
pip install dash
使用 Jupyter 笔记本电脑…
import dash
import dash_core_components as dcc
import dash_html_components as html
import plotly.graph_objs as go
import pandas as pd
from dash.dependencies import Input, Output
实时更新
作者图片
在这一部分，我们将讨论如何让您的仪表板实时运行。
是的，你没听错。
Dash 允许其用户通过更新其数据源来实时自动化仪表板，而无需任何交互。这是通过实现间隔组件来实现的。
仪表板核心部件—间隔
dash 核心组件中的 interval 组件是一个触发器，它将定期触发回调。要在应用程序上实现这一点，只需将间隔连接到您需要更新的标签或图表，然后让奇迹发生。
我们将通过一个简单的例子来探讨这个问题。
app = dash.Dash()app.layout = html.Div([
html.H1(id='live-counter'),
dcc.Interval(
id='1-second-interval',
interval=1000,
n_intervals=0
)
])[@app](http://twitter.com/app).callback(Output('live-counter', 'children'),
[Input('1-second-interval', 'n_intervals')])
def update_layout(n):
return 'This app has updated itself for {} times, every second.'.format(n)if __name__ == '__main__':
app.run_server()
作者图片
在本节中，我们简单地定义了一个 H1 标签和一个区间组件。然后我们定义了一个回调函数，将区间组件作为输入，将 H1 标签作为输出。
组件中的一个重要属性是 interval 属性，它定义了组件触发的频率。在这里，我们采取 1 秒钟的间隔。
这意味着回调函数会每 1 秒自动触发一次。
最后，我们可以利用 interval 组件中的 n 属性，它会根据我们定义的时间间隔自动更新。只需插入 n 作为我们显示的文本的一部分，以显示实时变化。
向上拉平
让我们把它提高一个档次，好吗？
我们如何为实际的图实现这一点？
很简单，我们更新图表本身。
作者代码
作者图片
在这个代码块中，我们简单地定义了一个图形组件和一个区间组件。然后我们定义了一个回调函数，将 interval 组件作为输入，图形的数字作为输出。
在我开始解释之前，一个好的流程图总是有帮助的。
作者图片
每秒钟，带有随机数的新数据被追加到我们的数据源中。然后基于那个更新的数据源绘制一个新的图表。应用程序上的图形随后会被更新后的图形替换为。
这里，我们只是将随机数作为数据插入到数据源中。但是，如果您正在跟踪，您将知道您可以基于您的管道轻松地追加/覆盖您的数据源**。**
你在实时搜集数据吗？
您是否在为您的网站可视化交易数据？
您可以轻松地将它声明为您的数据源，并每一秒/每一分/每一天都将其可视化。
我希望你现在意识到 Dash 有多强大。如何利用它取决于你的想象力。
注意:注意更新图表的时间间隔太小。拥有实时数据而没有真正的用例是不明智的，因为在更新数据源时可能会有极其繁重的计算，更不用说绘制极其繁重的图形了。
高级定制
所以现在你已经能够建立图表并自动化它们了。下一步是什么？
你需要设计和定制你的网络应用，让它对用户来说看起来很漂亮。从颜色到定位，Dash 让你只用一行代码就能轻松做到。
半铸钢ˌ钢性铸铁(Cast Semi-Steel)
CSS 代表层叠样式表，它是设计 HTML 标签样式的主要语言。如果你希望美化你的网络应用，学习 CSS 是必须的。
如何添加 CSS
Dash 允许您在 Python 代码本身中添加 CSS。
对于 Dash 中几乎每一个 组件，都有一个名为‘style’的属性，允许你通过 Python 字典为那个组件声明 CSS。
html.H1(children='Hello World!',
style={'width':'20%','display':'inline-block'})
那很酷。然而，如果您的 web 应用程序可伸缩，有一种更好的方法来声明您的 CSS。
专门为每个组件声明 CSS 是低效的，它还会降低应用程序的加载时间。
因此，我们可以在 Dash 中使用 Classname 解决方案，它本质上是 HTML 元素的 class 属性。
截图来自剧情
在开始 Dash 代码的同一个文件夹中，创建另一个名为 assets 的文件夹，并将所有 CSS 和 Javascript 代码放入其中。默认情况下，最新的 Dash 版本将读取所有以。css 和。js 从资产文件夹并将其应用到 web 应用程序。
app.py:
app = dash.Dash(__name__)app.layout = html.H1(children='Hello World!',
className= 'H1-Text H1-Text-Display')if __name__ == '__main__':
app.run_server()
app.css:
.H1-Text{
width:20%;
}.H1-Text-Display{
display:inline-block;
}
这样，您可以在 Dash 代码中为不同的组件重用类。
让它更干净更快捷。
注意:为了让 Dash 默认读取 assets 文件夹，请在声明 app = dash 时包含 name in。破折号(name)。
结论
祝贺你， 你在短跑方面又上了一个台阶。
在这篇文章中，你学到了—
- Dash —实时更新
- 破折号—添加 CSS
极限是天空。现在去吧，做点东西，和我分享。我等着呢。
在你走之前
我们的数据之旅还没有结束。我正在撰写更多关于数据行业的故事、文章和指南。你绝对可以期待更多这样的帖子。与此同时，请随意查看我的其他文章来暂时填补您对数据的渴望。
像往常一样，我引用一句话作为结束。
数据是新的科学。大数据掌握着答案*。
—*VMware 首席执行官帕特·基尔辛格
订阅我的简讯保持联系。
也可以通过 我的链接 注册一个中等会员来支持我。你将能够从我和其他不可思议的作家那里读到无限量的故事！
我正在撰写更多关于数据行业的故事、文章和指南。你绝对可以期待更多这样的帖子。与此同时，你可以随时查看我的其他 文章 来暂时填补你对数据的渴望。
感谢 的阅读！如果你想和我联系，请随时通过 nickmydata@gmail.com 联系我或者我的 LinkedIn 个人资料 。你也可以在我的Github中查看之前写的代码。
用于数据科学的 Python 在执行机器学习之前要做什么？
不要沉迷于机器学习模型，先了解你的数据。
你好，读者，
欢迎来到另一集“数据会让你变得富有”,在这里我将分享我的经验、指南和我的数据之旅的故事。
如果你是来学习新东西的，请继续阅读，我保证你会从我的所有文章中有所收获，因为我的主要动机是为我的观众提供价值。这就是我介绍自己的方式，即使是在面试中。
本周，我们将谈论机器学习。
对，大家都感兴趣的话题。每个数据科学家都在展示他们的模型，比较他们的准确度分数，而他们中的一些人甚至不知道这些数据是关于什么的。
谷歌趋势的机器学习趋势
机器学习正在兴起。我们都知道。
基于 Google Trends，它甚至与数据科学本身作为一个话题不相上下，
我们都知道数据科学有多热门。
我经常看到，当谈到数据时，初级数据从业者脑海中闪现的第一件事是机器学习……而且不仅仅是他们。
最近，我参加了公司内部的黑客马拉松。
由组织的最高管理层决定的进入前 3 名的想法，都与机器学习有关。在这一点上，很难忽视机器学习，因为每个人都在学习。
然而，只有极小比例的数据从业者能做好。
忘记人工智能吧——在大数据这个勇敢的新世界里，我们应该提防的是人工白痴。—汤姆·查特菲尔德
不要误解我。我不是来攻击机器学习的。相反，我在这里指导你如何做得更好。不要在没有首先了解什么是业务需求的情况下盲目地投入机器学习。在了解你的数据集之前，不要开始考虑用什么算法。如果你没有完全掌握你的问题陈述，又是什么影响了它，你怎么知道应该包括哪些栏目？
我们很多人都被细节所困扰，但最终，这完全取决于我们能为我们工作的组织提供多少价值。为了提供这样的影响，我们必须完全理解我们的数据集，这就引出了我的下一个话题。
数据探索
照片由威利安·贾斯登·德·瓦斯康塞洛斯在 Unsplash 上拍摄
在决定对数据集执行何种技术之前，您必须首先完全理解它。你可以通过探索数据集来实现。
探索是以发现信息或资源——维基百科为目的的搜索行为
下面是维基百科(100%可信)在 Exploration 上提供的定义。现在把它应用到你的数据集中。
就像上面的图像一样，您现在处于数据集中的陌生区域。你可以通过问这样的问题来更好地理解它:
- 数据集的目标是什么？
- 我们试图衡量的指标是什么？
- 每列是什么意思？
为了回答这些问题，我们通过使用熊猫来彻底检查数据。如果我们能够可视化某些点，那就更清楚了。
先决条件
数据探索大量使用熊猫。
因此，你应该可以轻松地浏览它。你可以通读一下我写的关于熊猫基础知识的文章来刷新你的记忆。
10 分钟内完成数据探索指南
towardsdatascience.com](/python-for-data-science-basics-of-pandas-5f8d9680617e)
除了熊猫之外，我们也将视觉化我们的发现。我对自己的可视化感到自豪，因为它让我有能力绘制出交互式图形。这在探索过程中非常有用，因为我可以流畅地浏览图表。如果你是 Plotly 的新手，请仔细阅读我关于如何使用 Plotly 的文章。
[## 面向数据科学的 python——Plotly 数据可视化指南
现在是 2020 年，是时候停止使用 Matplotlib 和 Seaborn 了
towardsdatascience.com](/python-for-data-science-a-guide-to-data-visualization-with-plotly-969a59997d0c) [## 用于数据科学的 Python 使用 Plotly 进行数据可视化的高级指南
如何在 Plotly 中添加和自定义滑块、下拉菜单和按钮
towardsdatascience.com](/python-for-data-science-advance-guide-to-data-visualization-with-plotly-8dbeaedb9724)
我几乎涵盖了你在这里需要的一切。不客气
现在你已经设置好了，剩下的就是进入代码了。让我们直入主题吧。
进口
像往常一样，我们将与 Jupyter 笔记本 一起工作。
#all plotly
from plotly.offline import init_notebook_mode,iplot
import plotly.graph_objects as go
import cufflinks as cf
init_notebook_mode(connected=True)#others
import pandas as pd
import numpy as np
导入数据集
在本文中，我们将使用一个 电信客户流失数据集 。
df = pd.read_csv(filepath)
数据集摘要
df.head(5)
df.info()
df.head()和 df.info()是获得数据集良好感觉的一种极其快速和简单的方法。从这里，我们可以通过查看数据集的前 5 行来大致了解数据集。
然而，我们看到有 21 列，Jupyter 不能提前显示所有内容。因此，我们还没有一个清晰的图像。
查看 df.info()，我们可以看到有 7032 行和 21 列。我们还可以看到所有列的名称、数据类型以及有多少非空值。巧合的是，所有的列都有 7032 个非空值，这意味着在我们的数据集中没有任何缺失数据。通常情况下，情况并非如此。我们可以通过以下方式检查缺失的数据:
df.isnull().sum()
这将返回所有的列以及每一列有多少 null 值。
之后，我们希望了解所有列的含义。
既然这是一个已发布的数据集，你可以在 数据集上找到 本身的链接。
再说一遍，通常不是这样。我们可以通过以下方式进一步了解我们的专栏:
df.nunique()
这将返回所有列及其唯一值的数量。
我们首先定义我们的度量。
为什么首先要创建这个数据集？
它是为了研究(和预测)某个电信公司的流失而创建的。
因此，很明显这里的列 Churn 是我们的度量列。
我们观察到 customerID 有 7032 个唯一值，这与数据集中的行数相同。这意味着 customerID 是我们的唯一行标识符。
对于月费用、总费用和任期列，我们可以根据它们拥有的唯一值和它们的数据类型推断出它们是数值列。
对于剩余的列，我们看到它们有 2、3 和 4 个唯一值。这可能意味着它们是分类列。
为了总结我们刚刚获得的信息并充分利用它们，我们可以为它们创建变量:
#defining all our columns
Id_col = ['customerID']
metric_col = ["Churn"]
cat_cols = df.nunique()[df.nunique() <= 4][df.nunique() > 2].keys().tolist()
cat_cols = [x for x in cat_cols if x not in metric_col]
bool_cols = df.nunique()[df.nunique() == 2].keys().tolist()
bool_cols = [x for x in bool_cols if x not in metric_col]
num_cols = [x for x in df.columns if x not in cat_cols + metric_col + Id_col + bool_cols]
探索数据集
探索数据集有不同的方式。我个人的做法是首先围绕指标栏，因为这是我们试图研究的内容。
到现在为止，你可能已经明白，这是一个包含 7032 名客户的数据集，以及他们所有的属性，如果他们已经停止使用该公司的服务。因此，我们可以研究他们拥有的属性和他们的流失率之间的关系。
一个简单的例子就是性别列。
基本问题比如—
离职的男性还是女性多？
我们肯定可以通过探索我们的数据集来回答这个问题。
让我们先来看看有多少真正的客户被搅了。
#defining data
trace = go.Pie(labels=df["Churn"].value_counts().keys().tolist(),
values=df["Churn"].value_counts().values.tolist(),
marker=dict(colors=['red']),
# Seting values to
hoverinfo="value"
)
data = [trace]#defining layout
layout = go.Layout(title="Churn Distribution")#defining figure and plotting
fig = go.Figure(data = data,layout = layout)
iplot(fig)
看起来大约有 27%的顾客放弃了他们的服务。
由于我们的客户流失列仅包含 2 个唯一值，即“是”或“否”。
我们可以将数据集分为流失的客户和停留的客户。这样我们可以更深入地研究数据。****
#Separating customers who churned and customers who stayed
churn = df[df["Churn"] == "Yes"]
not_churn = df[df["Churn"] == "No"]
别在我面前睡着了，我们才刚刚开始。
让我们首先处理所有的分类列以及它们与我们的度量标准的关系。我们进一步将我们的分类列分为布尔型和分类型，布尔型本身只有两个唯一值。
让我们来看看所有的分类列及其实际的唯一值。
#all categorical columns and thier unique values
for i in cat_cols:
for j in df[i].unique().tolist():
print(i + ' unique values are ' + j)
有几列像在线备份和在线安全同时包含值否和无互联网服务。对我们来说，这本质上意味着同样的事情，那就是他们没有那个特征。因此，我们可以将所有无互联网服务转换为无。
columns_to_be_replaced = [ 'OnlineSecurity', 'OnlineBackup', 'DeviceProtection',
'TechSupport','StreamingTV', 'StreamingMovies']for i in columns_to_be_replaced :
df[i] = df[i].replace({'No internet service' : 'No'})
我们的数据现在更清晰了，更容易处理。
形象化
下一步是对照我们的指标来可视化我们所有的特性。重要的是以一种你的观众容易阅读的方式来形象化它。
分类列:
我绘制了多个支线剧情来展示分类特征相对于变动的分布，从而实现了这种可视化。
如果你觉得很难理解，刷新我的文章:
#defining data
data = {}
for i in cat_cols:
for j in df[i].unique().tolist():
data[i + '_' + j] = go.Bar(
x=['churn','not churn'],
y=[(churn[i][churn[i] == j].value_counts().values.tolist()[0]/churn[i].value_counts().values.sum())*100,(not_churn[i][not_churn[i] == j].value_counts().values.tolist()[0]/not_churn[i].value_counts().values.sum())*100],
name = j,width=0.4)
对于上面的代码块，我们为的每个唯一值定义了一个条形图，该值出现在的每个列中。结果我们总共有 13 个痕迹。
#defining layout
layout = go.Layout(
title = 'Distribution of Categorical Columns in customer attrition',
barmode='stack',
showlegend= False
)#defining figure and plotting
fig = tools.make_subplots(rows=2, cols=2, subplot_titles = ('MultipleLines', 'InternetService', 'Contract', 'PaymentMethod'))
fig.append_trace(data['MultipleLines_No phone service'], 1,1)
fig.append_trace(data['MultipleLines_No'], 1,1)
fig.append_trace(data['MultipleLines_Yes'], 1,1)
fig.append_trace(data['InternetService_DSL'], 1,2)
fig.append_trace(data['InternetService_Fiber optic'], 1,2)
fig.append_trace(data['InternetService_No'], 1,2)
fig.append_trace(data['Contract_Month-to-month'], 2,1)
fig.append_trace(data['Contract_One year'], 2,1)
fig.append_trace(data['Contract_Two year'], 2,1)
fig.append_trace(data['PaymentMethod_Electronic check'], 2,2)
fig.append_trace(data['PaymentMethod_Mailed check'], 2,2)
fig.append_trace(data['PaymentMethod_Bank transfer (automatic)'], 2,2)
fig.append_trace(data['PaymentMethod_Credit card (automatic)'], 2,2)
fig.layout.update(layout)
iplot(fig)
从图中，我们可以清楚地观察到流失客户与非流失客户的某些模式。首先，大部分流失客户订阅了按月合同，而留下来的客户分享了几乎相同的 T2 分布。这可能表明逐月订阅本身存在产品缺陷。我不会在这里进入所有的细节，但我们可以有效地得出某些结论，这将有助于我们以后的机器学习模型。
让我们对布尔列做同样的事情。
#defining data
data = {}
for i in bool_cols:
for j in df[i].unique().tolist():
data[i + '_' + j] = go.Bar(
x=['churn','not churn'],
y=[(churn[i][churn[i] == j].value_counts().values.tolist()[0]/churn[i].value_counts().values.sum())*100,(not_churn[i][not_churn[i] == j].value_counts().values.tolist()[0]/not_churn[i].value_counts().values.sum())*100],
name = j,width=0.4)
trace = list(data.keys())#defining layout, fig and plotting
fig = tools.make_subplots(rows=4, cols=3, subplot_titles = ('Partner','SeniorCitizen','Partner', 'Dependents',
'PhoneService', 'OnlineSecurity', 'OnlineBackup', 'DeviceProtection',
'TechSupport', 'StreamTV','StreamingMovies','PaperlessBilling'))
fig.append_trace(data[trace[0]], 1,1)
fig.append_trace(data[trace[1]], 1,1)
fig.append_trace(data[trace[2]], 1,2)
fig.append_trace(data[trace[3]], 1,2)
fig.append_trace(data[trace[4]], 1,3)
fig.append_trace(data[trace[5]], 1,3)
fig.append_trace(data[trace[6]], 2,1)
fig.append_trace(data[trace[7]], 2,1)
fig.append_trace(data[trace[8]], 2,2)
fig.append_trace(data[trace[9]], 2,2)
fig.append_trace(data[trace[10]], 2,3)
fig.append_trace(data[trace[11]], 2,3)
fig.append_trace(data[trace[12]], 3,1)
fig.append_trace(data[trace[13]], 3,1)
fig.append_trace(data[trace[14]], 3,2)
fig.append_trace(data[trace[15]], 3,2)
fig.append_trace(data[trace[16]], 3,3)
fig.append_trace(data[trace[17]], 3,3)
fig.append_trace(data[trace[18]], 4,1)
fig.append_trace(data[trace[19]], 4,1)
fig.append_trace(data[trace[20]], 4,2)
fig.append_trace(data[trace[21]], 4,2)
fig.append_trace(data[trace[22]], 4,3)
fig.append_trace(data[trace[23]], 4,3)
fig.layout.update(layout)
iplot(fig)
太美了。从这里，我们可以判断某个特性在流失客户和非流失客户之间的分布是否有很大差异。首先，我们可以看到像无纸化记账和合作伙伴这样的功能有很大的不同。再说一遍，我不想深入讨论，但你会意识到，你可以在这里做出某些结论。
数字列:
让我们想象一下流失客户和非流失客户的每个数字特征的分布。我们先从任期开始。
#defining data
trace1 = go.Histogram(x = churn['tenure'],
histnorm= "percent",
name = "Churn Customers",
marker = dict(line = dict(width = .5,
color = "black"
)
),
opacity = 1
)
trace2 = go.Histogram(x = not_churn['tenure'],
histnorm = "percent",
name = "Non churn customers",
marker = dict(line = dict(width = .5,
color = "black"
)
),
opacity = .7
)
data = [trace1,trace2]#defining layout
layout = go.Layout(dict(title ='tenure' + " distribution in customer attrition ",
plot_bgcolor = "rgb(243,243,243)",
paper_bgcolor = "rgb(243,243,243)",
xaxis = dict(gridcolor = 'rgb(255, 255, 255)',
title = 'tenure',
zerolinewidth=1,
ticklen=5,
gridwidth=2
),
yaxis = dict(gridcolor = 'rgb(255, 255, 255)',
title = "percent",
zerolinewidth=1,
ticklen=5,
gridwidth=2
)
),barmode = 'overlay'
)#defining figure and plotting
fig = go.Figure(data=data,layout=layout)
iplot(fig)
很快我们就能看到分布的巨大差异。
具体来说，在流失的客户中，大约有一半只在电信公司呆了不到 3 个月。另一方面，留下来的客户在任期上分享了一个相当平均的分配，稍微偏向于更长的任期。
让我们对总费用和月费用做同样的事情。
#defining data
trace1 = go.Histogram(x = churn['MonthlyCharges'],
histnorm= "percent",
name = "Churn Customers",
marker = dict(line = dict(width = .5,
color = "black"
)
),
opacity = 1
)trace2 = go.Histogram(x = not_churn['MonthlyCharges'],
histnorm = "percent",
name = "Non churn customers",
marker = dict(line = dict(width = .5,
color = "black"
)
),
opacity = .7
)
data = [trace1,trace2]#defining layout
layout = go.Layout(dict(title ='MonthlyCharges' + " distribution in customer attrition ",
plot_bgcolor = "rgb(243,243,243)",
paper_bgcolor = "rgb(243,243,243)",
xaxis = dict(gridcolor = 'rgb(255, 255, 255)',
title = 'monthlycharges',
zerolinewidth=1,
ticklen=5,
gridwidth=1
),
yaxis = dict(gridcolor = 'rgb(255, 255, 255)',
title = "monthlycharges",
zerolinewidth=1,
ticklen=5,
gridwidth=1
)
),barmode = 'overlay'
)#defining figure and plotting
fig = go.Figure(data=data,layout=layout)
iplot(fig)
类似地，我们看到大多数购买了的顾客每月花费了 70 到 110 的费用。另一方面，大多数入住的顾客每月花费少于 30 美元。作为一名数据从业者，您可以与企业沟通，进一步了解这些客户将钱花在了什么产品/服务上，并进一步分析该产品/服务。
#defining data
trace1 = go.Histogram(x = churn['TotalCharges'],
histnorm= "percent",
name = "Churn Customers",
marker = dict(line = dict(width = .5,
color = "black"
)
),
opacity = 1
)trace2 = go.Histogram(x = not_churn['TotalCharges'],
histnorm = "percent",
name = "Non churn customers",
marker = dict(line = dict(width = .5,
color = "black"
)
),
opacity = .7
)
data = [trace1,trace2]#defining layout
layout = go.Layout(dict(title ='TotalCharges' + " distribution in customer attrition ",
plot_bgcolor = "rgb(243,243,243)",
paper_bgcolor = "rgb(243,243,243)",
xaxis = dict(gridcolor = 'rgb(255, 255, 255)',
title = 'TotalCharges',
zerolinewidth=1,
ticklen=5,
gridwidth=1
),
yaxis = dict(gridcolor = 'rgb(255, 255, 255)',
title = "TotalCharges",
zerolinewidth=1,
ticklen=5,
gridwidth=1
)
),barmode = 'overlay'
)#defining figure and plotting
fig = go.Figure(data=data,layout=layout)
iplot(fig)
总费用是而不是一个很好的特征来做出结论。想想吧。
客户的任期越长，客户花费的总费用越高。因此，总费用直接受到该客户的租期和月费用的影响。我们看到，大多数流失客户的总支出少于 **100，**这是有道理的，因为我们知道，大多数流失客户在前 3 个月就退出了。
也就是说，让我们想象一下任期和每月 费用之间的关系，同时了解这两个特征对总费用的影响。当我们这样处理多个变量时，我会想到泡沫图。
#defining data
trace1 = go.Scatter(x=churn['MonthlyCharges'],y=churn['tenure'],mode = "markers",marker = dict(line = dict(color = "blue"),
size=churn['TotalCharges']/180,
color = 'blue',
),
opacity = .9
,name='churn',showlegend=True)trace2 = go.Scatter(x=not_churn['MonthlyCharges'],y=not_churn['tenure'],mode = "markers",marker = dict(line = dict(color = "red"),
size=not_churn['TotalCharges']/180,
color = 'red',
),
opacity = 0.5
,name='not_churn',showlegend=True)
data = [trace1, trace2]
#defining layout
layout = go.Layout(dict(title = 'Monthly Charges vs Tenure (radius = total charges)',
plot_bgcolor = "rgb(243,243,243)",
paper_bgcolor = "rgb(243,243,243)",
xaxis = dict(gridcolor = 'rgb(255, 255, 255)',
title = "monthly charges",
zerolinewidth=1,ticklen=5,gridwidth=2),
yaxis = dict(gridcolor = 'rgb(255, 255, 255)',
title = "tenure",
zerolinewidth=1,ticklen=5,gridwidth=2),
height = 600
)
)#defining figure and plotting
fig = go.Figure(data,layout=layout)
iplot(fig)
从图中，我们可以看到，代表总电荷的气泡在图的右上角变大。这实质上意味着总费用直接取决于每月费用和客户的使用期限。
至此，您已经对数据集有了相对扎实的 理解。我将在这里停止我的探索，但这只是我自己。您可以从不同角度进一步研究数据集，例如了解要素之间的关系。天空是极限。
您还可以在这里找到本文的完整代码:
此时您不能执行该操作。您已使用另一个标签页或窗口登录。您已在另一个选项卡中注销，或者…
github.com](https://github.com/nickefy/what-to-do-before-machine-learning/blob/master/What%20To%20Do%20Before%20Machine%20Learning.ipynb)
恭喜
我赞扬你坚持到最后，因为这可能意味着你对数据充满热情**。你应该担心，它正在接管。**
简而言之，这里是你在这里学到的东西:
- 数据探索
- 拆分不同类型的数据
- 在数据中定义行标识符、度量和功能
- 可视化数据以帮助探索
你现在更愿意建立一个机器学习模型来预测客户的流失，这也是我下一篇文章要做的。
在你走之前
我们还没有完成这个数据集。我将对这个数据集执行分类机器学习，以预测客户下次是否会流失。我还在撰写更多关于数据行业的故事、文章和指南。你绝对可以期待更多这样的帖子。与此同时，请随意查看我的其他文章来暂时填补您对数据的渴望。
最后，我总是会引用一句话。
数据是新的科学。大数据掌握着答案。— 安吉拉·阿伦茨
订阅我的时事通讯，保持联系。
感谢 的阅读！如果你想与我取得联系，请随时通过 nickmydata@gmail.com 或我的 linkedIn 个人资料 联系我。也可以在我的Github中查看代码。
金融 Python:现代投资组合理论的实现
现代投资组合理论和有效边界概念在 Python 中的实现。
该脚本的输出是一个用散景创建的交互式仪表板。有 3 个主要区域:代表有效边界的图，股票价格的时间序列，以及具有最小风险、最大夏普比率和最大回报的投资组合的组成。
现代投资组合理论
现代投资组合理论(MPT)是一种用数学术语描述诸如多样化和风险管理等概念的金融理论。MPT 为投资者提供了建立多元化投资组合的工具，在给定的风险水平下，投资组合的回报最大化。风险通常用标准差来衡量。
这个理论是由经济学家哈里·马科维茨提出的，他因为这项研究获得了 1990 年的诺贝尔经济学奖。该理论的数学公式涉及方差和协方差等概念。如有兴趣了解详情，请访问 维基百科专用页面 。
有效边界
有效边界的概念可以正式定义为在任何给定风险下具有最高回报的投资组合集合，它与 MPT 密切相关。该边界通常呈“C”形，如下图所示，可以区分三个点:
- 风险最小的投资组合。
- 回报最大的投资组合。
- 具有最大夏普比率的投资组合，这通常是投资者的首选，因为它被认为是风险水平和预期回报之间的良好折衷。
MPT 的 Python 实现
下面介绍的 Python 笔记本使用户能够通过模拟定制数量的投资组合，轻松探索投资机会的设计空间，并创建一个可用于选择所需交易策略的交互式仪表盘。
完整的代码可以在下面的链接中找到，在我的 GitHub 页面上，还有“python for finance”系列的其他脚本。
现场脚本执行数值模拟，并找到最佳的投资组合构成符合现代…
github.com](https://github.com/r-poli/ModernPorfolioTheory)
实现是用 Python 3 实现的，数据的下载是通过 FINNHUB 应用编程接口(API)完成的。用户需要注册(注册是免费的)来获得个人 API 密钥。
该脚本由 3 部分组成:输入部分，主体和绘图部分。用户必须指定以下输入:
- 感兴趣的股票或交易所交易基金(ETF)的符号列表(例如，特斯拉公司的“TSLA”；“VOO”为先锋 500 指数基金 ETF 等。)，包括每只股票或 ETF 的简短描述。
- 她/他想要模拟的投资组合数量。
- 她/他希望用来执行回溯测试的日期范围。
- API 密匙，很容易免费获得这里。
*## DEFINE INPUTS*
**ticks** = ["EMB", "AGG", "VGT", "TSLA", "AMZN"]
**line_name** = ["Emerging countries debt", "US debt", "S&P 500 Vanguard ETF", "Tesla", "Amazon"]
**num_port** = 1000
**start_date** = '01/06/2015'
**end_date** = '27/06/2020'
**api_key** = "YOUR API KEY"
你可以在我的 GitHub 页面的笔记本中找到关于代码的更多评论和其他细节。在那里，您还可以找到“Python for finance”系列的其他工具。
享受，快乐交易！
https://www.linkedin.com/in/riccardopoli/里卡多里坡
T6
**免责声明:**投资股市有风险，可能导致金钱损失。这篇文章的内容不能作为财务建议。
Python for Finance —分析应收账款
分析应收账款对于识别潜在的公司收款问题非常重要。
应收账款是客户欠公司的金额。在这个故事中，我们将使用 Python 来分析科技行业公司的应收账款。这个故事将分成两部分。首先，我们将开始分析苹果公司的应收账款。然后，我们将分析科技行业中一组可比公司的应收账款与销售比率。
如何阅读应收账款
应收账款是公司的金融资产，因为它们代表公司因销售商品或服务而拥有的金额。
投资者经常用来比较公司间应收账款的比率之一是应收账款对销售比率。就销售额而言，应收账款的高比率表明一个公司有很大比例的赊销。高比率会给公司带来一定的风险，因为债务人可能无法偿还债务。
每个公司都需要估计有多少应收账款无法收回。这些被称为坏账应收账款，会减少公司的利润和应收账款总额。因此，保持较低的应收账款水平可能被视为一个好迹象，因为公司计提的坏账准备将因此减少。
另一方面，非常低的应收账款与销售比率可能表明一个公司对其客户过于积极。因此，积极的收集方法可能会影响公司与客户的关系，从而影响销售。
使用 Python 进行应收账款趋势分析
首先，我们将使用 Python 为 Apple 执行应收款趋势分析。这将向我们展示应收账款在过去几个季度的绝对值是如何变化的。
我们将使用免费的财务 APIfinancialmodelingprep来检索财务数据。如果您已经阅读了我之前的文章，那么下面的代码对您来说会很熟悉。因此，我不会详细介绍它的功能。
基本上，我们向 API 端点发出 get 请求来检索资产负债表数据。然后，我们解析响应以提取应收款数据并将其添加到 Python 字典中。
最后，我们将字典转换成熊猫数据框架。
import requests
import pandas as pd
all_Receivables = {}
stock = 'AAPL'
balanceSheet = requests.get(f'https://financialmodelingprep.com/api/v3/financials/balance-sheet-statement/{stock}?period=quarter')
balanceSheet = balanceSheet.json()
all_Receivables[stock] = {}
for item in balanceSheet['financials']:
receivables = item['Receivables']
period = item['date']
all_Receivables[stock][period] = receivables
all_Receivables
receivables_apple = pd.DataFrame.from_dict(all_Receivables, orient='index')
receivables_apple = receivables_apple.T
一旦我们有了 Pandas 数据框架，我们就可以使用库 Plotly 来绘制条形格式的应收账款:
import plotly.express as px
fig = px.bar(receivables_apple, x=receivables_apple.index,y =receivables_apple[stock],title='Account Receivables: ' + stock)
fig.show()
使用 Python 比较公司间的应收账款
在上一节中，我们绘制了苹果公司的应收账款趋势。我们可以看到应收账款随着时间的推移在增加。这可能是由于销售额的增长转化为更高水平的应收账款。
因此，仅仅关注应收账款可能不足以帮助投资者。在本节中，我们将进一步分析这两种情况:
- 应收账款对销售比率。这将表明销售方面的应收账款水平。这将非常有助于将一家公司与可比较的公司进行比较。
- 同行业不同公司的应收账款对比。
首先，正如你在下面的代码部分看到的，我们有一个在技术领域运营的公司列表。在我之前的一篇文章中，我向你展示了如何通过程序提取一个行业中所有公司的报价。
接下来，我们遍历列表中的每个公司，以便 提取应收账款和收入来计算应收账款与销售额的比率。 接下来，我们将这三个变量添加到一个 Python 字典中。最后，正如我们在上一节中所做的，我们将字典转换成熊猫数据帧。
technological_companies = ['MSFT','AAPL','AMZN','GOOG','IBM','CSCO','ORCL','SAP','IBM']
all_Receivables = {}
for company in technological_companies:
try:
#Retrieve Balance Sheet Data for each of the companies in the list
balanceSheet = requests.get(f'https://financialmodelingprep.com/api/v3/financials/balance-sheet-statement/{company}?period=quarter')
balanceSheet = balanceSheet.json()
all_Receivables[company] = {}
for item in balanceSheet['financials']:
receivables = item['Receivables']
all_Receivables[company]['receivables'] = receivables
IS = requests.get(f'https://financialmodelingprep.com/api/v3/financials/income-statement/{company}?period=quarter')
IS = IS.json()
for item in IS['financials']:
revenues = item['Revenue']
all_Receivables[company]['Revenue'] = revenues
all_Receivables[company]['receivables_to_sales'] = float(receivables)/float(revenues)
except:
pass
receivables_companies = pd.DataFrame.from_dict(all_Receivables, orient='index')
receivables_companies = receivables_companies.T
print(receivables_companies)
然后，我们执行一些数据操作，只保留行 receivables_to_sales ，因为这是我们想要绘制的信息。
#keep only receivables to sales
receivables_companies = receivables_companies[receivables_companies.index =='receivables_to_sales']
receivables_companies = receivables_companies.T.reset_index()
最后，在清理数据框架后，我们可以使用 Plotly 绘制不同公司的应收账款与销售比率:
import plotly.express as px
fig = px.bar(receivables_companies, x=receivables_companies['index'],y =receivables_companies['receivables_to_sales'])
fig.show()
应收账款比较
包扎
我们已经看到了两种简单的方法来分析单个公司以及一组可比公司的应收账款。
在我们的例子中，我们可以看到，与同行公司相比，IBM 的应收账款与销售额比率非常高。作为完成我们分析的下一步，我们需要查看公司财务报告的财务注释，以了解高比率的原因。是因为 IBM 向客户提供长期付款吗？或者可能是公司没有足够的能力来管理应收账款的回收？
另一个极端，我们有比率非常低的亚马逊。这可能是因为亚马逊业务的一部分是直接销售给即时付款的客户。
在 Twitter 上关注我，了解更多关于 Python for Finance 的信息。
原载于 2020 年 4 月 16 日【https://codingandfun.com】。
金融 Python:金融市场的自动化分析
一种高度自动化的方法，用于按业务部门分析金融市场的表现。
本文中介绍的 Python 脚本已经被用于分析新冠肺炎对标准普尔 500 指数的各个业务部门的影响，但是也可以很容易地适用于任何其他的金融市场分析。
代码是用 Python 编程语言开发的，可以在我的 GitHub 存储库(下面的链接)中找到，作为一个 Jupyter 笔记本。
这款 Jupyter 笔记本使用户能够对以下行业或子行业进行自动股票市场分析
github.com](https://github.com/r-poli/FinancialMarketAnalysis)
该脚本使用标准的 Python 包(即 pandas、bokeh、math)以及用于下载标准普尔 500 股票价格的 yfinance API(应用程序编程接口)。该 API 可以免费使用，并且是公共的，这意味着用户不需要单独的 API 密钥。
***# Import libraries***
import **yfinance** as yf
import **pandas** as pd
from **bokeh**.plotting import figure
import **bokeh**.models as bmo
from **bokeh**.palettes import Paired11
from **bokeh**.io import show
from **bokeh**.models import ColumnDataSource, HoverTool
import **math**
在脚本的第一部分，用户需要定义名为 “depth” 的变量来定义分析的详细程度。这可以设置为“扇区或“子扇区”。选择“扇区将产生如图 1 所示的图，而“子扇区将产生类似于图 2 和图 3 所示的图。在最后一种情况下，用户还必须指定**“过滤器”**，即感兴趣的部分。过滤器的可用值有:通信服务、非必需消费品、消费品、能源、金融、医疗、工业、信息技术、材料、房地产和公用事业。
***# Example of input definition***
**depth** = '*sub_sector*'
**filter** = '*Information Technology*'
所有其他输入，如标准普尔 500 股票列表，以及当前市场表现的比较日期(2020 年初)都是自动设置的。
index_name = 'SP_500'
companies = pd.read_html('https://en.wikipedia.org/wiki/List_of_S%26P_500_companies', flavor='bs4')[0]
此时，数据被下载，所有的计算被执行。正如预期的那样，yfinance API 用于收集财务数据。
df_all = pd.DataFrame()
color_df = pd.DataFrame({0})**for** stock **in** companies_codes:
stock_data = yf.Ticker(stock.replace(".",""))
stock_name = companies[company_label].loc[companies[code_label] == stock].values[0]
df_all[stock_name] = stock_data.history(start="2020-01-01")['Close']
最后一部分是创建所有图的地方。
if depth == 'sector':df_sector = df_summary.groupby(['Sector']).mean()
df_sector = df_sector.sort_values(by=['YTD_performance'], ascending=False)source2 = ColumnDataSource(data=dict(cum_sum_ytd=df_sector.YTD_performance.to_list(), sector=df_sector.index.to_list()))p = figure(plot_height=700, plot_width=1200, x_range=df_sector.index.to_list(), toolbar_location='right', y_range=[-50, 50],
title='Year-to-date performance of individual sectors (S&P 500 stocks)', tools="save")color_map = bmo.CategoricalColorMapper(factors=df_summary['Sector'].unique(), palette=Paired11)p.vbar(x='sector', top='cum_sum_ytd', width=0.9, source=source2, fill_color={'field': 'sector', 'transform': color_map},
legend='sector', line_width=0)p.xaxis.major_label_orientation = math.pi/3
p.yaxis.axis_label = 'Year to date average performance (%)'p.title.text_font_size = '12pt'
p.yaxis.axis_label_text_font_size = '12pt'show(p)
您可以在 GitHub 页面上的笔记本中找到对代码的进一步评论和其他细节。
新冠肺炎对金融市场的影响
在本节中，图 1、图 2 和图 3 总结了上述代码的输出。
新冠肺炎对我们的生活、习惯、实体经济和金融市场产生了前所未有的影响。疫情造成的金融冲击并不一致，各商业部门对危机的反应也不同。
从图 1 中可以看出，总的来说，所有部门都受到了疫情的负面影响，能源部门的损失最大。事实上，由于世界人口的很大一部分被封锁，对石油和天然气的需求大幅下降。工业部门也经历了重大损失，特别是在“航空航天和国防”以及“航空”分部门。主要原因是对这些服务的需求减少，这是由于现有的限制和对新冠肺炎病毒传播的恐惧。
医疗保健
医疗保健是受影响最小的行业，生物技术子行业的一些公司股价平均上涨了 16%，见图 2。这是因为许多公司正在新冠肺炎疫苗上投入资源。赢得这场竞赛的公司可能会有丰厚的利润。
图二。新冠肺炎对标准普尔 500“医疗保健”股的影响
通信服务
在这个前所未有的时代，智能工作以及人们对讲话和看望亲人的渴望增加了对视频会议应用程序和软件的需求。由于人们在许多国家被隔离，他们倾向于在流媒体服务上花费更多时间。因此，家庭娱乐和电信服务在疫情期间表现良好(分别增长 12%和 23%)，图 3。
图 3。新冠肺炎对标准普尔 500“通讯服务”股票的影响
如果你想阅读更多关于该主题的内容，请参考我在几周前(2020 年 5 月)写的这篇文章，解释新冠肺炎对每个业务部门和子部门的影响。
注意安全，交易愉快！
https://www.linkedin.com/in/riccardopoli/ 里坡
**免责声明:**投资股票市场有风险，可能导致金钱损失。这篇文章的内容不能作为财务建议。
面向金融的 Python 完全初学者指南
使用亚马逊股票数据的简单实践
欢迎阅读面向金融的 Python 完全入门指南。
在这篇文章中，我将带你完成一些很棒的实践练习，帮助你了解如何使用 Python 进行金融。首先，我将把你介绍给我们的朋友 Pyhton，然后我们将进入有趣的部分，即编程。正如副标题中提到的，我们将使用亚马逊股票数据。如果你想知道是否可以免费获得这些数据，答案是肯定的。股票数据可以在纳斯达克官方网站上找到。纳斯达克(全美证券交易商自动报价协会)是一个电子股票交易所，拥有 3300 多家上市公司。
亚马逊股票数据可以从这里下载。在这个网站上，你可以找到不同公司的股票数据，并使用这些数据集练习你的技能。我等不及了，让我们开始吧！
目录:
- 计算机编程语言
- 了解亚马逊股票数据
- 数据清理
- 数据可视化
计算机编程语言
Python 是一种通用编程语言，在分析数据方面越来越受欢迎。Python 还能让您快速工作，更有效地集成系统。世界各地的公司都在利用 Python 从他们的数据中收集知识。官方 Python 页面如果你想了解更多。
理解数据
当您第一次将数据加载到 dataframe 中时，在开始操作它之前查看它是一个好习惯。这有助于理解你有正确的数据和一些关于它的见解。如前所述，在这个练习中，我们将使用一家纳斯达克公司的历史数据。我认为亚马逊是个不错的选择。在和我一起完成这个练习后，你将会学到一些技巧，让你能够使用不同的数据集来练习。
我们将使用的数据框架包含过去一个月(2020 年 6 月 24 日至 7 月 23 日)亚马逊股票的收盘价。
读出数据
import pandas as pd amzn = pd.read_csv('amzn_data.csv')
头部方法
为了对数据有所了解，我们要做的第一件事是使用 head 方法。当您在 dataframe 上调用 head 方法时，它会显示 dataframe 的前五行。运行这个方法后，我们还可以看到我们的数据是按日期索引排序的。
amzn.head()
结果
尾部法
另一个有用的方法我们称之为尾部方法。它显示数据帧的最后五行。假设您想查看最后三行，您可以在括号之间输入整数 3。
amzn.tail()
结果
描述方法
在深入之前，我们要调用的最后一个方法是 describe 方法。它返回给我们数据的统计摘要。默认情况下，describe 方法将返回所有数字列的汇总统计信息，例如在我们的示例中，所有列都是数字。汇总将包括以下项目:行数、平均值、标准偏差、最小值和最大值，最后是百分位数。
amzn.describe()
描述方法
为什么我们只得到 Volume 列的值，而没有得到其他列的值？这就是我们所说的数据准备。清理数据并为分析做好准备是一个主要步骤。在我们进行下一步之前，有几件事我们必须注意。请随意查看下面的帖子，了解更多关于使用不同列数据类型时的数据清理。
使用 pandas 操作数据类型的简单说明
medium.com](https://medium.com/python-in-plain-english/cleaning-data-in-python-data-types-46f9ebf2feef)
数据清理
我们前面提到 describe 方法专门处理数值，这意味着 Volume 列是我们的数据帧中唯一的数值。让我们检查列的数据类型。
amzn.dtypes
列数据类型
正如您在上面看到的，Volume 列是唯一的整数类型，其余的是对象类型。所以我们必须注意数据类型。但是在转换它们之前，我们已经清理了美元符号，否则，当我们试图将美元符号转换成数值时，我们的程序将会混乱。
amzn = amzn.replace({'\$':''}, regex = True) amzn.head()
去掉美元符号后
很好，现在我们可以转换数据类型了。我们不需要对日期和数量列做任何修改。我们将把 rest 列转换成一个数值，对于这个练习，我们可以使用 float 数值类型。
# Renaming column names and converting the data typesdf = amzn df.columns = ['Date', 'Close', 'Volume', 'Open', 'High', 'Low'] # Converting data types
df = df.astype({"Close": float, "Volume": int, "Open": float, "High": float, "Low": float}) df.dtypes
更改后的数据类型
太好了，我们解决了数据类型问题。现在，让我们尝试运行 describe 方法，看看它是如何工作的。
df.describe()
结果
干得好！现在，正如您在上面看到的，describe 方法与我们所有的数字列配合得非常好。我们还可以通过使用不同的参数来定制 describe 方法的结果。Describe 有三个我们将在本例中使用的参数:include、percentiles 和 exclude。
df.describe(include = "float")
结果
df.describe(include = "object")
结果
df.describe(exclude = "int")
结果
df.describe(percentiles = [0.1, 0.5, 0.9])
结果
过滤数据
比较运算符
- <
- <=
-
=
- ==
- !=
我们将使用这些运算符将特定值与列中的值进行比较。结果将是一系列的布尔值:真和假。如果比较正确，则为真，如果比较不正确，则为假。
被收盘价掩盖
当我们使用 loc[]运算符将一个布尔序列传递给一个数据帧时，将返回一个只包含真值的新数据帧。
# Closing price more than 3000mask_closeprice = df.Close > 3000 high_price = df.loc[mask_closeprice] high_price.head()
结果
Pandas 提供了运算符来组合布尔比较的不同结果。这些运算符是:And、Or、Not。我们可以使用这些运算符来创建更复杂的条件。例如，假设我们要查看收盘价超过 3000 且成交量超过 500 万的 AMZN 股票数据。我们是这样做的:
# Closing price more than 3000 and traded volume more than 5mask_closeprice = df.Close > 3000
mask_volume = df.Volume > 5000000millionhigh_price_volume = df.loc[mask_closeprice & mask_volume]
high_price_volume.head()
结果
数据可视化
可视化数据是理解数据的重要一步。它帮助我们看到的不仅仅是一行行的值，它让我们对数据有了更好的了解。当我们想要在不同的数据值之间进行比较时，它也是有帮助的。
可视化数据也是理解和查看不同列之间关系的好方法。
Matplotib
最常用的 2D 绘图库叫做 Matplotlib。这个库非常强大，它也有一个学习曲线。在这个学习曲线的帮助下，围绕这个库建立了其他库。
让我们画出过去一个月的股票价格。我们的 x 轴是日期，y 轴是每天的收盘价。这将向我们展示股票价格在一个月内的变化。从商业角度来说，这种线图被称为价格波动图，它有助于检测股价的季节性模式。
df.plot(x='Date', y='Close')
线形图
旋转
plot 方法提供了许多有趣的参数，您可以尝试一下。其中一个是旋转参数，使用这个参数我们可以旋转图的标签。下面是一个将日期标签旋转 90 度以便于阅读的例子。
df.plot(x='Date', y='Close', rot=90)
线形图
标题
如果你想给你的情节一个标题，这是使用的方法。我们将传递一个字符串到我们的标题参数中。
df.plot(x='Date', y='Close', rot=90, title="AMZN Stock Price")
线形图
更多绘图类型
绘图方法的默认类型是折线图，但是根据我们的使用情况，还有许多其他绘图类型可供使用。其他一些绘图类型可以列举如下:
- 线条
- 酒吧
- 馅饼
- 分散
- 柱状图
我们来做一个散点图的例子。我们将在我们的方法中添加一个名为 kind 的新参数。是的，就是这么简单。
df.plot(x='Date', y='Close', kind='scatter', rot=90, title="AMZN Stock Price")
散点图
现在我们来做一个直方图的例子。直方图是查看数值分布的好方法。
df.plot(x='Date', y='Volume', kind='hist', rot=90, title="AMZN Stock Price")
直方图
感谢你阅读这篇文章，我希望你喜欢并且今天学到了一些新的东西。如果您在执行代码时有任何问题，请随时通过我的博客联系我。我非常乐意帮忙。你可以找到更多我发表的与 Python 和机器学习相关的帖子。保持安全和快乐的编码！
我是贝希克·居文，我喜欢分享关于创造力、编程、动力和生活的故事。
面向初学者的简单交互式教程
towardsdatascience.com](/introduction-to-python-for-data-science-6d1dba7c305c) [## 用 Python 构建语音识别器
使用谷歌云语音 API 将您的音频文件转换为文本
towardsdatascience.com](/building-a-speech-recognizer-in-python-2dad733949b4)
扫一扫
721
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
