TowardsDataScience 博客中文翻译 2019（五百三十七）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

嵌入关系的可视化

原文：https://towardsdatascience.com/visualisation-of-embedding-relations-word2vec-bert-64d695b7f36?source=collection_archive---------17-----------------------

在这个故事中，我们将可视化单词嵌入向量，以理解由嵌入描述的单词之间的关系。这个故事重点讲 word2vec [1]和 BERT [2]。为了理解嵌入，我建议阅读不同的介绍(比如这个)，因为这个故事并不打算描述它们。

这个故事是我使用 BERT 情境化嵌入向量开发神经机器翻译(NMT)之旅的一部分。欢迎建议！

单词嵌入

单词嵌入是为单词生成计算机友好的数字向量表示的模型。Word2vec 为每个单词产生 300 个介于 0 和 1 之间的浮点数。对计算机来说可能更容易理解，但对人来说则相反。

下图显示了 5x60 矩阵中 300 数值的灰度像素。看着图像，我们能观察到的东西并不多。

我们可以认为，第 42 列的较轻值在所有与人类相关的单词中是相似的，而在单词 apple 中是完全不同的。

另外，queen-woman+man = king是计算机可以理解的东西。字典中与queen-woman+man最接近的单词是king，这被认为是单词嵌入的重要特征之一。但是很难看到。

Word2vec representation of certain words

嵌入投影

嵌入投影背后的基本思想是将表示向量的维度减少到 2D 或 3D，因此它可以被可视化。这背后的数学称为线性投影:如果我们有一个 n 维向量 x ，我们想要一个 m 维投影(m < n) y ，我们需要找到一个 m*n 矩阵 A ，秩为 m，并计算 y =A x 。

Illustration of projection in Wikipedia (cc)

让我们关注 2D！如果我们想要一个投影，其中某个单词到(1，0)点，而另一个单词到(0，1)点，我们想要解 I=AX 线性方程，其中 I 是 2 大小相同的矩阵， A 是投影的矩阵， X 矩阵包含我们想要的作为列的基础中的向量。

如果 A 矩阵是一个方阵，这就是 X 的逆矩阵，这个问题可以用高斯消去法很容易地解决。这里，我们希望将更大的向量投影到 2D 子空间中，因此，它不是一个正方形矩阵(对于 word2vec 为 2x300，使用 BERT base 为 2x768)。这里我们要的叫做左逆矩阵。然而，我们将使用伪逆或 Moore-Penrose 逆 ，因为它在 Numpy 中有一个实现，并且生成一个接近于单位([numpy.linalg.pinv](https://docs.scipy.org/doc/numpy/reference/generated/numpy.linalg.pinv.html))的矩阵。

好吧。我们来编码吧！我们有一个单词列表:[‘man’, ‘woman’, ‘rich’, ‘poor’, ‘queen’, ‘king’, ‘fisherman’, ‘teacher’, ‘actress’, ‘actor’]我们想要一个 2D 子空间，其中男女线是一个轴，贫富线是另一个轴。为此，我们将把man-woman投影到(1，0)并将rich-poor投影到(0，1)，在投影之后，我们将移动这些点以适合轴。

Code to project words for 2D visualisation

下图显示了投影的结果。观察这张图片我们可以看到一个渔夫，一个国王和一个演员更像一个男人，而不是一个女王或女演员。同样，我们可以说一个国王和一个王后接近富而一个老师接近穷。

Projection of the words in a subspace with poor-rich and man-woman axes

要看更高级的 word 投影，我可以推荐 TensorFlow 嵌入式投影仪。

句子投射

BERT 提供了依赖于上下文的嵌入。在这里，我们想要研究，我们能从中观想什么。我之前没有看到类似的东西，所以可能是第一次有人这么做。否则，我很高兴在评论中看到其他解决方案！

这种可视化背后的思想是，BERT 中的每个句子都以一个[CLS]标记开始，以一个[SEP]标记结束，因此，将句子投影为(1，0)是[CLS]标记，而(0，1)是[SEP]标记，我们可以在 2D 子空间中说明句子，并且嵌入以所有句子都从(1，0)开始并以(0，1)结束的方式进行归一化。

[CLS] This is a sentence example. [SEP]

这背后的数学原理和以前一样。我们使用预先训练好的 BERT base bert_12_768_12_book_corpus_wiki_en_uncased。

Code for the sentence-dependent embedding projection

为了演示令牌的顺序，让我们用箭头将点连接起来！我们可以观察到第一个标记’，‘更靠近起始标记和最后一个标记’。’离安德令牌更近，但其他的都在相对较小的区域。

Sentence visualisation using contextualised embeddings

让我们把句子中的单词’ sky 改成’ sea '！点天空和海洋被标记。我想指出的是，主要区域中的点的顺序被改变了(尝试在故事的结尾链接的代码以获得更好的分辨率)。虽然海句子没有十字箭头，但天空句子的顺序看起来完全是随机的。

Difference between the sky and the sea in the sentence “The … is blue today.”

让我们来调查时态的变化！从这张图片(与其他句子相比)来看，我认为这个模型在句子的时态方面没有太大的差异。

Difference between tenses. is / was / will be

与时态相比，句末的标点符号对嵌入的影响更大。

Difference between punctuation characters.

正如我们之前提到的，BERT 嵌入是依赖于上下文的。为了说明这一点，下面的例子展示了包含单词 Mexico 的复杂句子。墨西哥点被标记。

Sentences with Mexico in it

在前面的例子中，我们可以看到句子“那也在墨西哥”与我们到目前为止看到的其他句子有些不同。它主要在 2D 空间的负域区域上。换句话说，离[CLS]令牌还远着呢。

为了猜测为什么会发生这种情况，我们必须研究一下 BERT 的训练数据。使用两个无监督的任务来训练 BERT，其中一个是掩蔽语言建模(Masked LM)，另一个是下一句预测(NSP)。在第二个任务中，句子对用一个分隔符训练，像这样:
[CLS] This is the first sentence. [SEP] This is the second one. [SEP]

正如我们在这里看到的，第二个句子以一个[SEP]标记开始，而不是以[CLS]标记开始。我认为这是观察到的不规则现象背后的原因。换句话说，句子，即对话中的反应，可能离[CLS]标记更远。让我们看看能否用更多的例子来支持这个论点！

Possible reaction sentences to see x<0 points

我们也可以在 y<0 区域捕捉到一些点，但是不太明显。我认为对这些特殊句子的观察显示了进一步工作的潜力。

最后，让我们检查一些不正确的句子！我们可以看到，这些非句子也试图适应点的规则区域。

Incorrect sentences compared to two correct ones

摘要

在这个故事中，我们讨论了一种可视化单词嵌入的方法，并以一种新颖的方式讨论了将其用于句子可视化的想法。

所有代码都可以在 Google Colab 上找到。

参考

[1] Mikolov，t .，Chen，k .，Corrado，g .，& Dean，J. (2013 年)。向量空间中单词表示的有效估计。 arXiv 预印本 arXiv:1301.3781 。

[2] Devlin，j .，Chang，M. W .，Lee，k .，& Toutanova，K. (2018 年)。 Bert:用于语言理解的深度双向转换器的预训练。 arXiv 预印本 arXiv:1810.04805 。

用伯特的故事学习 NMT

1. BLEU-BERT-y:比较句子得分
2. 嵌入关系的可视化(word2vec，BERT)
3. 机器翻译:简要概述
4. 使用 BERT 识别单词的正确含义
5. 机器翻译:对比 SOTA
6. 使用 TensorFlow 2.0 的简单 BERT

来自原始 Twitter 数据的信息可视化——第二部分

原文：https://towardsdatascience.com/visualisation-of-information-from-raw-twitter-data-part-2-11707a65e920?source=collection_archive---------22-----------------------

想要了解用户活动，查看某些用户是否是机器人，制作 Tweet 出版物的时间序列等等吗？接着读下去！

前一篇文章介绍了如何从 Twitter 下载关于某个主题的数据，在 Jupyter 笔记本中准备好这些数据**，从这些数据中发现的见解，并探索了一些非常酷的可视化技术。如果您尚未阅读，您可以在此处找到它:**

[## 来自原始 Twitter 数据的信息可视化—第 1 部分

让我们探索一下我们可以从原始 Twitter 数据中轻松检索到什么样的信息！

towardsdatascience.com](/visualization-of-information-from-raw-twitter-data-part-1-99181ad19c)

这第二篇文章将描述其他令人敬畏的可视化，同时也探索一些可以从下载的 tweets 中获得的更多信息。

我们将从发现发布推文的用户的信息开始:

#Lets take a look at the users who are posting these tweets:print("There are {} different users".format(tweets['Username'].nunique()))

在我的例子中，条推文是由 59508 个不同的用户发布的。

使用我们精心准备的数据框架我们可以看到谁是发布最多推文的用户，更酷的是:看到高度活跃的用户成为机器人的几率！

#Going to see who are the users who have tweeted or retweeted the #most and see how
#Likely it is that they are botsusertweets = tweets.groupby('Username')#Taking the top 25 tweeting userstop_users = usertweets.count()['text'].sort_values(ascending = False)[:25]
top_users_dict = top_users.to_dict()
user_ordered_dict =sorted(top_users_dict.items(), key=lambda x:x[1])
user_ordered_dict = user_ordered_dict[::-1]#Now, like in the previous hashtags and mention cases, going to make #two lists, one with the username and one with the valuedict_values = []
dict_keys = []
for item in user_ordered_dict[0:25]:
    dict_keys.append(item[0])
    dict_values.append(item[1])

这段代码非常类似于我们在上一篇文章中使用的代码，以查看最常用的标签或提到的用户。现在，像前面的例子一样，我们将绘制结果。

#Plot these resultsfig = plt.figure(figsize = (15,15))
index = np.arange(25)
plt.bar(index, dict_values, edgecolor = 'black', linewidth=1)
plt.xlabel('Most active Users', fontsize = 18)
plt.ylabel('Nº of Tweets', fontsize=20)
plt.xticks(index,dict_keys, fontsize=15, rotation=90)
plt.title('Number of tweets for the most active users', fontsize = 20)
plt.savefig('Tweets_of_active_users.jpg')
plt.show()

Bar chart of the number of tweets produced by the top 25 tweeting users.

我们可以看到，最活跃的用户是 @CrytoKaku ，发布的推文超过 400 条。太多了！他/她是机器人吗？让我们来看看吧！

为此，我们需要下载并导入僵尸工具 Python 库，并获得一个能够使用他们的 API 的密钥。有关如何做到这一点的信息可以在以下链接中找到:

[## Botometer API 文档(OSoMe) | RapidAPI

Botometer(以前的 Truthy BotOrNot)检查 Twitter 账户的活动，并根据可能性给它打分

rapidapi.com](https://rapidapi.com/OSoMe/api/botometer?utm_source=mashape&utm_medium=301)

此外，我们将需要检索我们的 Twitter API 密钥，因为我们将需要它们来允许 Botometer 访问我们想要研究其活动的帐户的信息。

首先，我们将导入两个库。考虑到 Botometer 和 Tweepy 都必须使用您选择的软件包管理器预先下载。

#Now we will see the probabilities of each of the users being a bot #using the BOTOMETER API:import botometer
import tweepy

之后，我们将输入所需的 API 键:

#Key from BOTOMETER API
mashape_key = "ENTER BOTOMETER API KEY"#Dictionary with the credentials for the Twitter APIs
twitter_app_auth = {
    'access_token' : "ENTER ACCESS TOKEN",
    'access_token_secret' : "ENTER ACCESS TOKEN SECRET",
    'consumer_key' : "ENTER CONSUMER KEY",
    'consumer_secret' : "ENTER CONSUMER SECRET",    
}

像以前的文章一样，把“ 回车… ”换成相应的键，就可以了。

运行下面的代码块来访问僵尸工具 API，，让我们看看前 25 名推特用户中哪些账户最有可能成为僵尸工具！

#Connecting to the botometer API
bom = botometer.Botometer(wait_on_ratelimit = True, mashape_key = mashape_key, **twitter_app_auth)#Returns a dictionary with the most active users and the porcentage #of likeliness of them bein a Bot using botometerbot_dict = {}
top_users_list = dict_keys
for user in top_users_list:
    user = '@'+ user
    try:
        result = bom.check_account(user)
        bot_dict[user] = int((result['scores']['english'])*100)
    except tweepy.TweepError:
        bot_dict[user] = 'None'
        continue

这个模块的输出是一个字典 (bot_dict) ，其中的关键字是我们正在检查的帐户名称，值是一个介于 0 和 1 之间的数值分数，它描述了每个用户成为机器人的概率，其中考虑了某些因素，如关注者/被关注者的比例、帐户描述、发布频率、发布类型以及更多参数。

对于一些用户，Botometer API 得到一个 拒绝请求错误，所以这些将有一个“无”作为它们的值。

对我来说，我在检查 bot_dict 时得到如下结果:

{'@CryptoKaku': 25,
 '@ChrisWill1337': 'None',
 '@Doozy_45': 44,
 '@TornadoNewsLink': 59,
 '@johnnystarling': 15,
 '@brexit_politics': 42,
 '@lauramarsh70': 32,
 '@MikeMol1982': 22,
 '@EUVoteLeave23rd': 66,
 '@TheStephenRalph': 11,
 '@DavidLance3': 40,
 '@curiocat13': 6,
 '@IsThisAB0t': 68,
 '@Whocare31045220': 'None',
 '@EUwatchers': 34,
 '@c_plumpton': 15,
 '@DuPouvoirDachat': 40,
 '@botcotu': 5,
 '@Simon_FBFE': 42,
 '@CAGeurope': 82,
 '@botanic_my': 50,
 '@SandraDunn1955': 36,
 '@HackettTom': 44,
 '@shirleymcbrinn': 13,
 '@JKLDNMAD': 20}

这其中，成为 Bot 几率最高的账号是 **@CAGeurope，概率为 82%。**让我们来看看这个账户，看看为什么 Botometer 赋予它如此高的概率成为一个机器人。

Twitter account of @CAGeurope

这看起来像一个合法的帐户，然而，有各种各样的原因解释为什么 Botometer 给了它这么高的概率是一个机器人。首先，这个账户关注的账户数量几乎是关注它的账户数量的三倍。其次，如果我们看看他们的推文出版物的周期性，我们可以看到他们始终如一地每小时发布各种推文，有时间隔 5 分钟，这是一个很大的推文。最后，他们的推文的内容总是非常相似，都是简短的文本、一个 URL 和一些标签。

如果您不想编写任何代码或获取 API 密钥，Botometer 还提供了一个基于 web 的解决方案**，在这里您还可以检查帐户成为机器人的可能性:**

Web based solution offered by Botometer

看来我不得不停止发送垃圾消息和大量关注他人，以使我的 Twitter 账户更像人类:P

酷！通过 tweet 的 JSON 中的*‘user*’对象，我们可以看到更多关于用户的信息，然而，这将留到另一篇文章中。

现在，让我们制作一个推文出版物的时间序列，这样我们就可以看到哪一天关于所选主题的推文比较多，并尝试找出哪些事件导致了这些较高的推文产量**。**

我们将绘制特定月份每天发布的条推文的数量。要显示与此类似的图，但时间更长，必须添加一些额外的代码。

首先，我们需要修改 dataframe 的“时间戳字段，使用 Pandas incorporated 函数 to_datetime 将其转换为 Datetime 对象。

tweets['Timestamp'] = pd.to_datetime(tweets['Timestamp'], infer_datetime_format = "%d/%m/%Y", utc  = False)

然后，我们创建一个返回 DateTime 对象的日期的函数，并将其应用到我们的’ Timestamp’ ‘字段，为我们的 dataframe 创建一个新列，存储发布 tweet 的日期。此外，我们将把这些天组合在一起，统计每天产生的 tweets (使用’ text’ 字段)的数量，并用结果创建一个字典 ( timedict) ，其中键是对应于一个月中某一天的数字，值是当天发布的 tweets 的数量。

def giveday(timestamp):
    day_string = timestamp.day
    return day_stringtweets['day'] = tweets['Timestamp'].apply(giveday)
days = tweets.groupby('day')
daycount = days['text'].count()
timedict = daycount.to_dict()

做完这些，我们就可以准备好绘制我们的结果了！

fig = plt.figure(figsize = (15,15))
plt.plot(list(timedict.keys()), list(timedict.values()))
plt.xlabel('Day of the month', fontsize = 12)
plt.ylabel('Nº of Tweets', fontsize=12)
plt.xticks(list(timedict.keys()), fontsize=15, rotation=90)
plt.title('Number of tweets on each day of the month', fontsize = 20)
plt.show()

Time Series of 2 days tweet collection for the #Brexit (Left) and for a whole month on the #Oscars (right)

如果像我一样，你只收集了几天的推文，你会得到一个很短的时间序列，就像左边的图片。然而，右边的一个显示了从关于奥斯卡的推文的数据集制作的整月时间序列，这是通过查询一个多月推文的流媒体 API 构建的。在这第二个时间序列中，我们可以看到在月初很少有推文被生成，随着仪式日期的临近推文的生成开始上升，在活动当晚达到顶峰。

厉害！现在，我们将绘制一个关于从产生推文的设备的图。

由于该代码与前面的条形图所使用的代码非常相似，所以我将在这里发布它，不做进一步的解释:

*#Now lets explore the different devices where the tweets are #produced from and plot these resultsdevices = tweets.groupby('device')
devicecount = devices['text'].count()#Same procedure as the for the mentions, hashtags, etc..
device_dict = devicecount.to_dict()
device_ordered_list =sorted(device_dict.items(), key=lambda x:x[1])
device_ordered_list = device_ordered_list[::-1]device_dict_values = []
device_dict_keys = []
for item in device_ordered_list:
    device_dict_keys.append(item[0])
    device_dict_values.append(item[1])*

现在我们绘图，看看结果:

*fig = plt.figure(figsize = (12,12))
index = np.arange(len(device_dict_keys))
plt.bar(index, device_dict_values, edgecolor = 'black', linewidth=1)
plt.xlabel('Devices', fontsize = 15)
plt.ylabel('Nº tweets from device', fontsize=15)
plt.xticks(index, list(device_dict_keys), fontsize=12, rotation=90)
plt.title('Number of tweets from different devices', fontsize = 20)

plt.show()*

Plot of tweet production from different devices

通过查看这张图表，我们可以看到大多数推文是由智能手机发布的，在这一类别中，Android 设备以微弱优势击败了 Iphones。

网络产生的推文也可能来自移动设备，但产生于浏览器，而不是 Twitter 应用程序。除了这些网络发布的推文(我们无法判断它们是来自 PC、Mac 还是移动网络浏览器)，很少有推文来自公认的 Mac 或 Windows 设备。这些结果非常符合社交网络的轻松随和的本质。

最后，让我们看看一些可以从收集的数据中容易获得的额外信息

*#Lets see other useful information that can be gathered:#MEAN LENGTH OF THE TWEETS
print("The mean length of the tweets is:", np.mean(tweets['length']))#TWEETS WITH AN URL
url_tweets = tweets[tweets['text'].str.contains("http")]
print(f"The percentage of tweets with Urls is {round(len(url_tweets)/len(tweets)*100)}% of all the tweets")#MEAN TWEETS PER USER
print("Number of tweets per user:", len(tweets)/tweets['Username'].nunique())*

对我来说，这是平均长度为的145 条推文，23%的推文有 URL，平均每个用户的推文产量为2.23 条推文*。***

就是这样！你可以在这里 找到这篇文章和上一篇文章 使用的 Jupyter 笔记本，以及我关于 Twitter 数据收集的其他文章的脚本和笔记本。

还有，更多关于自然语言处理和机器学习的牛逼资源，可以看看这个牛逼的博客: 如何学习机器学习 。

非常感谢你的阅读，请鼓掌，继续发微博，再见！

用 Python 可视化选举

原文：https://towardsdatascience.com/visualising-elections-with-python-4973c0c60bbe?source=collection_archive---------11-----------------------

公平地说，全球政治格局目前正在发生很多变化，无论你是美国人、T2 人、以色列人、委内瑞拉人，还是介于两者之间的任何人(作为一名英国人，我有自己的地狱般的经历，比如英国退出欧盟)。不管任何政治局势的细微差别，它们都有一个共同点，那就是它们产生的丰富多样、复杂的数据，等待人们去探索。例如，考虑一下你可能需要知道什么来完美预测选举之夜的表现:理解宣言政策及其后果；对人们将如何对政策和政治家做出反应的心理理解；社会学关于人口变化和人们作为一个群体如何投票的知识；以及博弈论预测在给定的制度下人们会如何投票。

但在所有这些之前，一个未来的政治学家必须能够捕捉和想象人们的情绪。在本帖中，我们将通过绘制英国的选举地图，向选举之夜优势迈出第一小步。

这种地图，正式名称为 choropleth 地图，有多种风格。我将详细介绍我如何使用 Python 创建两种类型的 choropleth 地图:英国的地理现实地图和 hex 地图，如下所示。对这里产生的观想的分析将在以后的文章中讨论。用于生成地图的代码可以在我的 Github 上看到。

A giant election map on the BBC piazza. I’ve opted for a slightly higher-tech approach.

创建地理地图

为了创建英国的基本 choropleth，我选择使用 Python 包 GeoPandas ，它扩展了 Pandas 来处理地理空间数据。

GeoPandas 使得使用一种流行的 GIS 数据格式 shapefile 绘制地图变得很简单。对那些试图绘制英国地图的人来说幸运的是，划分成选区的地图——英国的投票边界——是由国家统计局免费提供的。只需从网站上下载你选择的任何粒度的地图作为形状文件。

注意:shapefiles 由几个单独的文件组成，它们包含独立的信息。你需要保存 zip 文件夹中提供的所有文件。

要在 GeoPandas 中加载和绘制 shapefile:

import geopandas as gpd
import matplotlib.pyplot as pltmap_df = gpd.read_file("uk_generalized_2015.shp")
# map_df is a Pandas dataframef, ax = plt.subplots(1, figsize=(6, 6))
ax = map_df.plot(ax=ax)
ax.set_axis_off()

Sorry, Northern Ireland.

正如我们所看到的，GeoPandas 将 shapefile 转换成我们都熟悉和喜爱的数据帧。

增添一些趣味

我们开始得很好，但是地图看起来很无趣。我们现在需要掌握一些选区级别的变量，通过这些变量我们可以给地图着色。

为了这篇文章的目的，我们决定使用签署请愿书的选民的百分比来废除第 50 条。给那些不知情的人一个简单的入门:英国公民可以通过政府官方网站发起请愿，如果达到一定数量的签名，政府将在议会辩论请愿的主题。2019 年 3 月，一份要求撤销英国离开欧盟的法律机制第 50 条的请愿书在短短几天内就获得了数百万个签名。

每份请愿书都附有一份 JSON，其中包括按议会选区划分的签名数量，因此我们可以很容易地绘制一张地图，直观地显示国民对任何请愿书的情绪。但是，在将这些数据添加到 dataframe 之前，我们需要将 JSON 转换成 csv。

import csv
import jsonfile = "petition_data.json"
with open(file, "r", encoding="utf-8") as json_file:
  data = json.load(json_file)
data = data["data"]["attributes"]["signatures_by_constituency"]keys = data[0].keys()
save_file = "petition_data.csv"
with open(save_file, 'w') as f:
  dict_writer = csv.DictWriter(f, keys)
  dict_writer.writeheader()
  dict_writer.writerows(data)

现在我们需要结合数据，计算签名数占选民的百分比。请注意，要做到这一点，我们还需要关于每个选区选民规模的信息，这些数据也可以在国家统计局网站上获得。

import pandas as pddata_df = pd.read_csv("petition_data.csv")# Combine the two dataframes by their constituencies
combined = map_df.set_index("pcon15nm")
           .join(data_df.set_index("name"))
           .reset_index()# Also join the dataset containing electorate numbers
# Not included here for brevity# Clean the data
combined["electorate"].fillna(1e8, inplace=True)
combined["mp"].fillna("No MP", inplace=True)
combined["signature_count"].fillna(0, inplace=True)# Calculate the percentage votes
combined["signature_pc"] = 100 * combined["signature_count"] /           
                           combined["electorate"] 

虽然我们从中检索数据的请愿书非常受欢迎，但任何选区的最大签名比例只有 40%左右。我们将色彩映射表的最大值设置为这个值，否则大部分选区会向色谱的一端移动到无法区分的程度。

fig, ax = plt.subplots(1, figsize=(6, 6))
combined_data.plot(column="signature_pc", cmap="viridis", 
                   linewidth=0.8, ax=ax)
ax.axis("off")

vmin = 0.
vmax = 40.
sm = plt.cm.ScalarMappable(cmap="viridis", 
                           norm=plt.Normalize(vmin=vmin, 
                           vmax=vmax))
sm._A = []
cbar = fig.colorbar(sm)

Overly large colourbars are in this year.

虽然这不是你见过的最漂亮的地图，但它让我们可以快速方便地看到某样东西在全国的受欢迎程度。

创建十六进制地图

看着上面的地图，你会有这样的想法，因为请愿书只在几个选区获得了很高比例的签名，所以总体来说，它不受欢迎。然而，熟悉这个国家的人可能会认出地图右下角的亮点。那个亮点是伦敦，它是几百万人的家园。

这很好地证明了绘制百分比而非绝对受欢迎程度的地图在得出结论时会误导人们。虽然像这样的地图对于展示一个事物的地理分布非常有用，但我们偏向于赋予更大的区域更大的重要性。

努力创造无偏见的视觉效果，无论最终可能多么徒劳，我们现在将绘制六边形地图——在地图中，每个选区由一个大小相等的六边形表示。这些地图用地理现实主义来平衡地图上每个区域的重要性。

首先，我们需要每个选区六边形的坐标。因为在十六进制地图中，区域的大小被严重扭曲(在英国，最小的选区是一平方英里，最大的选区超过 4000 平方英里)，所以不可能像在更真实的地图上那样排列选区。

在这篇文章中，我们从 ODILeeds 那里得到了底图，他们创造了一个神奇的工具来生成你自己的英国十六进制地图。对地图满意后，下载 HexJSON 并将其转换为 CSV 格式，如前所述。

不幸的是，研究用 Python 绘制这种地图的现成方法并没有取得成功:Matplotlib 的 hexbin 虽然目的相似，但将数据点隐藏起来，并且证明太难正确组织。有必要绘制单独的六边形，为此使用了 Matplotlib 补丁。下面是如何实现这一点的简单示例:

from matploblit.patches import RegularPolygon
import numpy as np

d = 0.5 / np.sin(np.pi/3)  # radius of poylgon
o = 0.5 * np.tan(np.pi/3)  # orientation of polygon
y_diff = np.sqrt(1 - 0.5**2)  
# difference in y location for consecutive layers

colors = ["red", "blue","green"]
hcoord = [0.5, 0, 1]
vcoord = [y_diff, 0, 0]

fig, ax = plt.subplots(1)

for x, y, c in zip(hcoord, vcoord, colors):
    hex = RegularPolygon((x, y), numVertices=6, radius=d,
                         facecolor=c, alpha=0.2, edgecolor='k')
    ax.add_patch(hex)ax.set_xlim([-0.5, 1.5])
ax.set_ylim([-0.6, 1.45])
plt.show()

Great maps, like great food, are built on honeycombs.

在创建全英国地图之前，剩下的一个挑战是计算出六边形的坐标:连续的行有一个交替的起点，这是蜂窝的性质。ODILeeds 提供的地图使用“ odd-r ”格式，这意味着奇数行包含最右边的六边形。

def calc_coords(row, column):
  if row % 2 == 1:
    column = column + 0.5
  row = row * y_diff
  return row, column

为了创建英国，我们遍历选区，并为每个区域绘制一个六边形。然而，当试图创建平滑的颜色图时，如上所述，手动提供颜色将是一项乏味的任务。我们利用 PatchCollection 对六边形进行分组，并提供一个 Matplotlib colourmap 来完成繁重的彩色提升。

from matplotlib.collections import PatchCollectionfig, ax = plt.subplots(1, figsize=(6, 6))
ax.axis("off")patches = []
colours = []
for i in range(combined.shape[0]):
  # here, combined is a join of hex csv and petition data
  # creating combined has been omitted for brevity
  row = combined.loc[i, "r"]
  col = combined.loc[i, "q"]
  row, col = calc_coords(row, col)
  c = combined.loc[i, "signature_pc"]hexagon = RegularPolygon((col, row), numVertices=6, radius=d, 
                         edgecolor='k')
patches.append(hexagon)
colours.append(c)p = PatchCollection(patches, cmap=plt.get_cmap("viridis"), 
                    alpha=1.0) 

Title and labels not included.

有了这张地图，我们可以看到伦敦的全貌，以及它与周围地区的对比。知道了选区的人口大致相似，我们就能更清楚地看到这一请愿在英国有多普遍。

最后的想法和下一步

除了这篇文章中所展示的，我还使用了定期从撤销第 50 条请愿书中获取的数据，以可视化整个英国的请愿书的传播。生成的地图可以在 GitHub 上看到。我最诚挚地感谢奥迪利兹的斯图尔特·劳收集并提供了请愿资料。

虽然回想起来我会认为这是一次成功的练习，但创建十六进制地图的过程让我相信，使用奇异的地图来可视化选举并不是 Matplotlib 非常适合的工作。如果我或任何阅读这篇文章的人决定创建更复杂的地图，可能有必要看看其他工具，如 d3 或牵牛星。

毫不奇怪，选举报道和分析的范围远远超出了本文的范围。有各种各样的地图用于覆盖世界各地的选举，每一张部署到传达稍微不同的意思。然而，这里探讨的两种类型可以构成相当翔实的政治分析的基础。

在这个项目之后，就我而言，我期待着英国的下一次选举，期待着有机会利用这些地图，如果没有其他事情的话。在那之前，我只能满足于请愿。

为深度学习可视化过滤器和特征图

原文：https://towardsdatascience.com/visualising-filters-and-feature-maps-for-deep-learning-d814e13bd671?source=collection_archive---------4-----------------------

想获得灵感？快来加入我的 超级行情快讯 。😎

深度神经网络是最强大的机器学习模型之一。有了足够的数据，它们在计算机视觉和自然语言处理(NLP)等任务中的准确性是无与伦比的。

许多科学家会评论的唯一缺点是，这些网络完全是黑箱作业。对于深度网络如何如此好地学习它们的目标模式，尤其是所有神经元如何一起工作以实现最终结果，我们仍然知之甚少。

对 ML 模型如何工作有某种内部了解会带来一些关键优势:

• 它们更容易调整，因为当我们看到网络出错时，我们可以直接指出原因
• 可以解释网络的功能和预期行为，特别是对非技术利益相关者
• 我们可以进一步扩展和改进模型的整体设计，因为我们已经了解了当前的设计，包括它的优点和缺点

令人高兴的是，研究人员已经开始探索理解深层网络内部情况的技术。特别是，我们现在有能力可视化卷积神经网络(CNN)从其计算机视觉任务训练中学习的过滤器，以及 CNN 应用于图像时产生的特征图。

本教程将教你如何做到这一点:可视化的过滤器和特征地图的 CNN 训练的图像分类。我们甚至可以在超级易用的 Keras 中完成！

挑选我们的模型

首先，我们需要选择一个模型来可视化。

在 Keras 中，最简单的方法是选择一个预先训练好的图像分类模型。在它的应用页面中有很多这些表现最好的模型。他们都在 ImageNet 数据集上进行了训练，该数据集包含超过 100 万张图片。

对于本教程，我将挑选 VGG16 型号。它很简单，我们可以浏览我们的教程，并仍然保持其作为一个相当准确的模型。结构如下所示。

在 Keras 中加载模型的过程如下所示。当您从keras.applications导入模型时，Keras 会自动将权重下载到适当的目录中。然后，我们加载模型并打印出它的结构概要。

可视化过滤器

我们将创建的第一个可视化是 CNN 过滤器。

当深度学习的人们谈论“过滤器”时，他们指的是卷积的学习权重。例如，单个 3×3 卷积称为“滤波器”，该滤波器总共有 10 个权重(9 + 1 偏差)。

通过可视化学习的权重，我们可以了解我们的网络学习得有多好。例如，如果我们看到许多零，那么我们将知道我们有许多对我们的网络没什么用的死过滤器——这是为模型压缩做一些修剪的好机会。

看看下面可视化过滤器的代码，然后向下滚动查看它如何工作的解释。

在导入了所有必需的库并加载了模型之后，我们在第 7 行构建了模型中各层的字典。这将允许我们通过层名称访问每个层的权重。如果你想查所有的名字，你可以打印出字典中的关键字。

接下来，我们将在第 9 行设置我们想要显示其滤镜的图层的名称。我选择了“block5_conv1 ”,但您可以选择任何您喜欢的卷积块。

在第 13 行中，我们调用get_weights()函数从我们选择的层中获取过滤器和偏置权重。

在第 16 行和第 17 行，我们对过滤器值进行了归一化处理，使它们介于 0 和 1 之间。当我们在屏幕上以颜色显示重量时，这将有助于创建清晰的视觉效果。

最后，我们从第 21 行开始的循环显示了一些过滤器。对于我们选择的“绿色”色图，黄色代表值 1，深蓝色代表值 0。

查看下面 VGG16 的 block5_conv1 层的输出！

可视化特征地图

CNN 的特征图捕捉将过滤器应用于输入图像的结果。即在每一层，特征图是该层的输出。

将特定输入图像的特征映射可视化的原因是为了试图了解我们的 CNN 检测到了什么特征。也许它检测到了我们想要的物体的某些部分，而没有检测到其他部分，或者激活在某一层消失了。

直接观察深度学习中的一个常见想法也很有趣，即网络的早期层检测低级特征(颜色、边缘等)，网络的后期层检测高级特征(形状和对象)。

看一下下面的可视化特征地图的代码，然后向下滚动查看它是如何工作的解释。

前两个步骤保持不变:加载模型并选择你想要可视化的层的名称。一个小的变化是我们修改了我们的模型，使得最终输出是 VGG16 的最后一个特征地图的输出，因为我们并不真正需要最后两个完全连接的层。

接下来，我们将在第 16 到 19 行加载并准备我们的图像。你可以选择任何你喜欢的图像；我选择了一个老虎的形象，因为老虎是令人敬畏的。

第 16 到 19 行的代码将读取图像并应用 VGG16 模型所需的必要预处理。如果您的图像像 4K 分辨率一样大，也不用担心，因为 VGG 总是希望图像的大小为 224x224，所以输入在处理之前总是会重新调整大小。

在第 22 行，我们将 VGG16 模型应用于输入图像；输出将是我们想要的特征地图。我们将遍历地图的几个通道，并在 matplotlib 图形中可视化它们。

查看下面的结果图。注意在图像的边缘和纹理上有很多激活，尤其是我们的老虎的轮廓！

喜欢学习？

在 twitter 上关注我，我会在这里发布所有最新最棒的人工智能、技术和科学！也在 LinkedIn 上和我联系吧！

Santa2Graph:使用 Giotto Mapper 可视化高维数据

原文：https://towardsdatascience.com/visualising-high-dimensional-data-with-giotto-mapper-897fcdb575d7?source=collection_archive---------13-----------------------

拓扑数据可视化的 Mapper 算法的简单介绍，包括使用 giotto-learn 中的实现的教程

由弗朗西斯科·帕尔马、大卫·伯巴、路易斯·汤斯顿、托马斯·博伊斯编剧

教程链接:https://github.com/giotto-ai/tutorial_mapper

除非你天生擅长数字，否则数据可视化仍然是数据分析最直接、最有效的洞察来源。特征之间的视觉相互作用提供了影响许多选择的洞察力，如特征工程和特征选择。

我们都喜欢有很多功能。好的一面是潜在的更多信息；不利的一面是很难分离这些信息。由于我们不能轻易地可视化三维以上的物体，标准的可视化方法不太适合高维数据。

Mapper 算法提供了一种在单个图形中可视化数据内在形状的方法。这个图表是通过一个巧妙的聚类过程构建的，揭示了底层数据的粗略结构。实际上，理论结果证实了输出的拓扑准确性。

在本文中，我们将介绍映射器算法，以及基于 giotto-learn 库给出的实现的教程。它的一个很酷的特性允许您与一些映射器参数进行交互，而无需重新运行代码。

Interactive Mapper available in giotto-learn.

映射器算法的应用

自 2007 年以来，Mapper 一直用于简化复杂交互的可视化。它提供了对大特征空间的定性分析，有助于在医学、材料科学和基因组学中的应用。最近，它也被应用于提高神经网络的鲁棒性。

下面我们总结了映射器算法的两个著名应用:

1)乳腺癌患者分析

在一项乳腺癌研究中，只有 200 名患者，需要一种专门的方法来处理基因型特征空间的 30k 维。Mapper 算法已成功应用于对患者进行更精细的细分，从而大大改善了靶向治疗。在两个不同的数据集上进行了相同的分析，并提供了一致的输出，证明了算法的稳定性。

2)NBA 球员的分类

如果你打过篮球，你就会知道篮球一直有五个位置:控卫、得分后卫、小前锋、大前锋和中锋。使用球员的统计数据和比赛中的表现，Mapper 算法确定了 13 种反映现代篮球动态的新打法。这让团队的总经理知道了组建团队时不可错过的技能。

映射器算法

摘自原创论文:

我们并不试图获得一个数据集的完全准确的表示，而是获得一个易于理解的低维图像，它可以指出感兴趣的领域。

为了生成表示数据结构的粗略图形，该算法将点合并成节点，并在不同节点的公共点处连接它们。

这个过程是由神经定理驱动的，它保证了映射器输出在拓扑上等同于数据采样的形状。

实际上，该算法是一个三步过程:

1. 过滤:我们通过使用过滤函数 f. 将数据点映射到ℝ
2. 覆盖:我们用重叠区间覆盖过滤值。
3. 聚类:对于每个区间，我们将一个聚类算法应用于在该区间中映射的观察值。

Among the points that are close in filter value, we cluster together the one that are similar in the original space. Nodes are connected whenever they share a point. (Source: https://arxiv.org/abs/1904.11044)

1)过滤

映射器的第一步在于通过过滤函数f:ℝⁿ→ℝᵐ.将每个数据点 x 映射到低维空间ℝᵐ通常我们选择 m=1 或者 m=2 。

过滤函数的选择对映射结果有很大的影响，因为过滤值较远的点没有机会聚集在一起。因此，过滤函数用作接近度的粗略测量。

在上图中，作者使用了高度函数，但是原则上任何函数都可以完成这项工作。但是，一些常见的选择是:

1. 轴上的投影
2. PCA
3. 怪癖
4. 密度
5. 熵

2)覆盖

我们以覆盖所有滤波器值的方式将图像空间划分成重叠的区间(或者区间的乘积，如果 m > 1 )。我们称这样的结构为盖。

通常我们将封面设定为由相同尺寸的 m 维间隔制成。例如，如果 filter 函数采用ℝ中的值，则 cover 由一系列等长的重叠线段组成。

在这种情况下，要选择的参数是间隔数及其重叠百分比。在上面的例子中，有 4 个 25%重叠的区间。

3)聚类

在最后一步中，我们在封面的每个区间上连续地执行聚类。通过过滤函数每次取间隔的预图像，在原始空间上进行聚类。输出图由以下部分组成:

• 节点，表示数据点的集群；
• 边缘代表聚类对(共享一些数据点的聚类)之间的非空交集。由于时间间隔重叠，这是可能的。

在这一点上，每个聚类代表图的一个节点，并且边对应于具有共同观察的聚类。

教程:使用映射器检索圣诞老人

直观理解映射器如何工作的最好方法是使用它并“玩”它的参数。

Giotto 是一个开源项目，包含 giotto-learn，一个易于使用的拓扑数据分析工具包。它使用了一个类似 Scikit-learn 的 API，并提供了一种通过管道函数来适应映射器的便捷方法。给定 Numpy 数组形式的数据集，构建图形的代码如下:

pipeline = make_mapper_pipeline(
    filter_func=Projection(column_indices=2),
    cover=OneDimensionalCover(n_intervals=10, overlap_frac=0.1),
    clusterer=DBSCAN(eps=0.5),
)
graph = pipeline.fit_transform(data)

我们将 Mapper 算法应用于数据集，该数据集包含从圣诞老人形状(即所谓的“圣诞老人云”)中采样的 20，000 个三维数据点。

Left: dataset sampled from here using CloudCompare. Right: Mapper output using different parameters.

作为第一次尝试，我们使用覆盖和聚类的默认参数以及高度上的投影作为过滤函数，即 f: [ x，y，z ]↦ z。我们通过点的平均颜色给每个节点着色:

With the default parameters Santa might make it through the chimney.

该图不代表数据集，因为我们无法区分圣诞老人身体的任何特征。除了节点的任意位置之外，给圣诞老人一个蛇形的外观，该图相当于一条连接节点的线。这表明聚类算法的默认参数需要改变，因为我们总是将所有的过滤器间隔聚集在一起。

为了解决这个问题，我们执行了更精细的聚类:

Mapper output: DBSCAN(eps = 0.06).

太好了！这是一个不平凡的图形结构。特别是我们看到树枝的外观，代表圣诞老人的胳膊和腿。然而，在这幅画中，圣诞老人有四只手臂。

我们通过调整封面中间隔之间的重叠部分(默认值为 0.1)来解决这个问题:

Mapper output: DBSCAN(eps = 0.06), overlap_frac = 0.35.

这次我们可以清楚地分辨出腿、胳膊和头。虽然它非常简单，但一般来说，这足以抓住主要结构。

我们可以通过增加封面中的区间数(默认为 10)来进一步完善我们的研究。这样，我们看到了代表帽子的节点的外观，以及将胸部与胡须分开的分支:

Mapper output: DBSCAN(eps = 0.06), overlap_frac = 0.35, n_intervals = 20.

结论

giotto-learn 库提供了 Mapper 算法的快速完整的 Python 实现。我们正在分享一个关于 3-d 数据的教程，现在你可以用你自己的映射图来表现高维数据集了。

特别感谢 Umberto Lupo 和Lewis Tunstall在 giotto-learn 中实现映射器。

链接:

• Github 上的 Giotto 库
• 包含代码的笔记本
• 更多学习资料请访问网站
• 化学函数的形状及其笔记本
• 足球的形状及其笔记本
• 检测股灾及其笔记本

用 Google 的 FACETS 可视化机器学习数据集。

原文：https://towardsdatascience.com/visualising-machine-learning-datasets-with-googles-facets-462d923251b3?source=collection_archive---------8-----------------------

谷歌的一个开源工具，可以从大量数据中快速学习模式

Photo by Franki Chamaki on Unsplash

更多的数据胜过聪明的算法，但更好的数据胜过更多的数据

关于大量训练数据如何对机器学习模型的结果产生巨大影响，已经有了很多争论。然而，除了数据量之外，质量也是构建一个强大而健壮的 ML 系统的关键。毕竟，“垃圾输入:垃圾输出”，也就是说，你从系统中得到的，将代表你输入到系统中的。

机器学习数据集有时由数千到数百万的数据点组成，这些数据点可能包含数百或数千个特征。此外，现实世界的数据是混乱的，包括缺失值、不平衡数据、异常值等。因此，在继续建模之前，我们必须清理数据。可视化数据可以帮助定位这些不规则性，并指出数据需要清理的地方。数据可视化提供了整个数据的概览，无论其数量多少，并能够快速准确地执行 EDA。

面状

facets 在字典中的意思可以归结为某事物的某一方面或特征。同样的， FACETS 工具帮助我们理解数据的各种特性并探索它们，而无需显式编码。

Facets 是 Google 在 对**(People+AI Research)**倡议下发布的开源可视化工具。这个工具帮助我们理解和分析机器学习数据集。Facets 由两个可视化组成，这两个可视化有助于挖掘数据并提供很好的洞察力，而无需在用户端做太多工作。

• 刻面概述

顾名思义，这种可视化提供了整个数据集的概览，并提供了数据的每个要素的形状。Facets Overview 总结了每个功能的统计信息，并比较了训练数据集和测试数据集。

• 刻面跳水

此功能有助于用户深入研究数据的单个特征/观察结果，以获得更多信息。它有助于一次交互式地探索大量数据点。

这些可视化实现为聚合物网络组件，由打字稿代码支持，可以很容易地嵌入到 Jupyter 笔记本或网页中。

使用和安装

有两种方法可以将方面用于数据:

网络应用

它可以直接从它的演示页面使用，其链接嵌入在下面。

[## 面向 ML 数据集的可视化

Dive 提供了一个交互式界面，用于探索所有不同的数据点之间的关系…

配对代码. github.io](https://pair-code.github.io/facets/)

这个网站允许任何人直接在浏览器中可视化他们的数据集，而不需要任何软件安装或设置，数据不会离开你的计算机。

在 Jupyter 笔记本/合作实验室内

也可以在 Jupyter 笔记本/协作室中使用刻面。这提供了更大的灵活性，因为整个 EDA 和建模可以在一个笔记本上完成。请参考他们的 Github 库以获得安装的完整细节。然而，在本文的后面，我们将看到如何在 colab 中使用刻面。

数据

虽然您可以使用演示页面上提供的数据，但我将使用另一组数据。我将在贷款预测数据集上做 EDA。问题陈述是为了预测一个申请人是否会偿还一家公司给予的贷款。这在 ML 社区中是一个众所周知的例子。

已经划分为训练集和测试集的**数据集，**可以从这里的 进入 。让我们把数据载入数据库。

import pandas as pd
train = pd.read_csv('train.csv')
test = pd.read_csv('test.csv')

现在让我们了解如何对这些数据使用 Facets Overview。

方面概述

概览自动让您快速了解数据各种要素的值分布。还可以即时比较训练和测试数据集之间的分布。如果数据中存在某种异常，它会立即从数据中跳出来。

通过此功能可以轻松访问的一些信息包括:

• 平均值、中值和标准差等统计数据
• 列的最小值和最大值
• 缺失数据
• 值为零的值
• 由于可以查看测试数据集的分布，我们可以很容易地确认训练和测试数据是否遵循相同的分布。

有人会说，我们可以用熊猫轻松完成这些任务，为什么我们要投资另一种工具。这是真的，当我们只有少量具有最小特征的数据点时，可能不需要。然而，当我们谈论大型数据集时，情况就不同了，在这种情况下，分析多列中的每个数据点变得有点困难。

谷歌协同实验室使工作变得非常容易，因为我们不需要安装其他东西。通过编写几行代码，我们的工作就完成了。

# Clone the facets github repo to get access to the python feature stats generation code
!git clone [https://github.com/pair-code/facets.git](https://github.com/pair-code/facets.git)

为了计算特征统计数据，我们需要使用 Python 脚本中的函数GenericFeatureStatisticsGenerator() 。

 # Add the path to the feature stats generation code.
import sys
sys.path.insert(0, '/content/facets/facets_overview/python/')# Create the feature stats for the datasets and stringify it.
import base64
from generic_feature_statistics_generator import GenericFeatureStatisticsGeneratorgfsg = GenericFeatureStatisticsGenerator()
proto = gfsg.ProtoFromDataFrames([{'name': 'train', 'table': train},
                                  {'name': 'test', 'table': test}])
protostr = base64.b64encode(proto.SerializeToString()).decode("utf-8")

现在，通过下面几行代码，我们可以轻松地在笔记本上显示可视化效果。

# Display the facets overview visualization for this data
from IPython.core.display import display, HTMLHTML_TEMPLATE = """<link rel="import" href="[https://raw.githubusercontent.com/PAIR-code/facets/master/facets-dist/facets-jupyter.html](https://raw.githubusercontent.com/PAIR-code/facets/master/facets-dist/facets-jupyter.html)" >
        <facets-overview id="elem"></facets-overview>
        <script>
          document.querySelector("#elem").protoInput = "{protostr}";
        </script>"""
html = HTML_TEMPLATE.format(protostr=protostr)
display(HTML(html))

当您输入Shift+Enter时，您会受到这个优秀的交互式可视化的欢迎:

在这里，我们看到了贷款预测数据集的五个数字特征的方面概述可视化。要素按不均匀性排序，分布最不均匀的要素位于顶部。红色的数字表示可能的故障点，在这种情况下，数字特征具有设置为 0 的高百分比值。右侧的直方图允许您比较训练数据(蓝色)和测试数据(橙色)之间的分布。

上面的可视化显示了数据集的八个分类特征之一。要素按分布距离排序，训练数据集(蓝色)和测试数据集(橙色)之间偏斜最大的要素位于顶部。

多面跳水

Facets Dive 提供了一个易于定制的直观界面，用于探索不同特征之间的数据点关系。使用 Facets Dive，您可以根据其特征值控制每个数据点的位置、颜色和视觉表示。如果数据点具有与其相关联的图像，则图像可以用作视觉表示。

要使用 Dive 可视化，必须将数据转换成 JSON 格式。

# Display the Dive visualization for the training data.
from IPython.core.display import display, HTML**jsonstr = train.to_json(orient='records')**
HTML_TEMPLATE = """<link rel="import" href="[https://raw.githubusercontent.com/PAIR-code/facets/master/facets-dist/facets-jupyter.html](https://raw.githubusercontent.com/PAIR-code/facets/master/facets-dist/facets-jupyter.html)">
        <facets-dive id="elem" height="600"></facets-dive>
        <script>
          var data = {jsonstr};
          document.querySelector("#elem").data = data;
        </script>"""
html = HTML_TEMPLATE.format(jsonstr=jsonstr)
display(HTML(html))

运行代码后，您应该能够看到以下内容:

Facets Dive Visualisation

现在，我们可以轻松地执行单变量和双变量分析，并让我们看看获得的一些结果:

单变量分析

在这里，我们将单独查看目标变量，即 Loan_Status 和其他分类特征，如性别、婚姻状况、就业状况和信用历史。同样，您也可以尝试不同的功能。

推论:

• 数据集中的大多数申请者都是男性。
• 同样，数据集中的大多数申请人都已经结婚并偿还了债务。
• 此外，大多数申请人没有家眷，是半城市地区的毕业生。

现在让我们来看一下顺序变量，即受抚养人、教育和财产面积。

从上面的柱状图可以得出以下推论:

• 大多数申请人没有任何家属。
• 大多数申请者都是毕业生。
• 大多数申请者来自半城市地区。

现在，您可以继续使用数字数据进行分析。

双变量分析

我们将找到目标变量和分类自变量之间的关系。

从上面的柱状图可以推断出:

• 对于已批准的贷款，已婚申请人的比例较高。
• 有一个或三个以上受抚养人的申请者在两种贷款状态类别中的分布是相似的。
• 似乎信用记录为 1 的人更有可能获得贷款批准。
• 半城市地区获得贷款批准的比例高于农村或城市地区。

结论

FACETS 提供了一个简单直观的环境来为数据集执行 EDA，并帮助我们获得有意义的结果。唯一的问题是，目前，它只适用于 Chrome 。

在结束本文之前，让我们也看看一个有趣的事实，它强调了如何使用 FACETS Dive 捕获 CIFAR-10 数据集中的一个小的人为标记错误。在分析数据集时，它注意到一张青蛙的图片被错误地标注为猫。嗯，这的确是一项成就，因为对于人类的眼睛来说，这是一项不可能完成的任务。

Source

在 Python 中可视化缺失的面板数据

原文：https://towardsdatascience.com/visualising-missing-panel-data-in-python-8dc79f6dbeb3?source=collection_archive---------20-----------------------

Photo by Iker Urteaga on Unsplash

如果您开始处理新的数据集，一个重要的分析是完整性测试。现实生活中的数据从来都不是完美的，可能经常包含缺失值。如果您正在使用 Pandas(如果您正在进行数据争论，您应该这样做)，有一些简洁的函数可以填充缺失的数据，比如 。菲尔娜() **。**但是，在填充缺失的数据之前，最好先了解缺失的内容等。这个简短的教程展示了面板数据完整性的一些可视化。

什么是面板数据？

Score 1 Dataframe

Score2 Dataframe

面板数据是多维数据，通常包含多个时间段的多个变量。例如，假设我们跟踪不同的健康得分(身体质量指数、血糖等。)对于一群多年来的参与者来说。对于每个变量(例如，得分 1、得分 2)，这将导致二维数据框架。这显然是不方便的，因为我们不想处理多个数据帧，并且认为 3D 是不直观的。因此，我们通常“堆叠”数据帧，其中每一行代表参与者和年份的唯一组合。

Stacked dataframe

让我们以堆叠格式创建一个面板数据集:

该样本包含一组人在 1955 年至 2019 年之间的(健康)得分。数据中有我们想要探究的缺失值(代码在最后)。打印数据帧的头部，我们可以看到很多缺失的数据。因此，我们希望对缺失的数据有更好的感觉，并试图了解是否有任何模式。

Head of the dataframe

我写了一个小函数，为感兴趣的变量创建一个图形。在 y 轴上，您可以看到观察结果(本例中为名称)。在 x 轴上你看到了年份。可用值以蓝色高亮显示，而缺失数据以灰色显示。

我们在这里能看到什么？

我们可以看到，Score 的可用值最多，而 Score 2 的可用值最少。大多数缺失值是随机的，但也有少数组成员没有值或所有值都可用(例如蓝色水平线)。这个函数可以在一个循环中使用，以方便地遍历所有变量，并允许直接发现模式。如果一些分数可以作为替代，我们应该在这种情况下使用 score1，因为它具有最完整的信息。

使用 2000 年至 2019 年间 1000 家公司的真实财务信息，图表如下所示。还有更多的信息缺失。我们可以直接发现，没有 2000 年的信息。此外，我们看到一些公司不是每季度报告一次，而是每年报告一次，只有每年第四季度的数据。一些公司只是出现的时间晚一些，而另一些则消失了。

可视化损失函数和梯度下降之间的关系

原文：https://towardsdatascience.com/visualising-relationships-between-loss-activation-functions-and-gradient-descent-312a3963c9a5?source=collection_archive---------6-----------------------

梯度下降处理损失/激活函数

本文假设你有训练神经网络的先验知识，并试图通过可视化揭示损失函数、梯度下降和反向传播之间的关系。

左图显示了损失函数和梯度下降之间的关系。

为了可视化梯度下降，想象一个过度简化为神经网络的最后一个节点输出一个权重值 w，目标值为 0 的例子。在这种情况下，损失函数是均方误差(MSE)。

当 w 大于 0 时，MSE 的导数 dy/dw 为正。正 dy/dw 可以解释为 w 的正阶跃将导致 y 的正变化，为了降低损耗，需要 w 方向的负阶跃:

当 w 小于 0 时，MSE 的 dy/dw 为负，这意味着 w 的正阶跃将导致 y 的负变化，为了降低损耗，需要在 w 方向上有一个正阶跃:

因此，总结权重更新的公式如下:

其中 learning_rate 是一个常数，用于调整导数应该步进的百分比。应该调整 Learning_rate，防止 w 的步长太小或太大。还应该调整 Learning_rate，以防止梯度爆炸(梯度过大)或消失梯度问题(梯度过小)。

对于更长且更实际的计算图，其中权重在 sigmoid 激活之后，为了更新权重 w1，损失相对于 w1 的导数可以如下找到:

the derivative of loss with respect to weight, w1

从上述步骤可以看出，神经网络中的权重是由损失函数的导数而不是损失函数来修正或反向传播的。损失函数对反向传播没有贡献。

L2 Loss

MSE (L2 损耗)的导数的大小为 2w。MSE 的导数的幅度变化有助于当 w 远离目标 0 时向 w 反向传播较大的步长，而当 w 靠近目标 0 时向 w 反向传播较小的步长

L1 Loss

平均绝对误差(MAE)(L1 损失)具有 1 或负 1 的常数导数，这在区分 w 离目标有多远时可能不理想。反向传播只使用损失函数的导数，不使用损失函数。

Cross-Entropy Loss

交叉熵损失只涉及 0 和 1 之间的 w 的定义域。当 w 接近 1 时，交叉熵减小到 0。交叉熵的导数是-1/w。

Sigmoid activation

Sigmoid 函数的导数范围在 0 到 0.25 之间。sigmoid 函数的导数的乘积可能导致非常小的接近于 0 的数，这使得反向传播无用。这就是所谓的消失梯度问题。

Relu activation

当导数为 1 或 0 时，Relu 成为良好的激活函数，允许在反向传播中对权重进行恒定更新或对权重进行 0 更新。

想象新加坡不断变化的天气模式:1983–2019

原文：https://towardsdatascience.com/visualising-singapores-changing-weather-patterns-1983-2019-a78605fadbdf?source=collection_archive---------11-----------------------

通过使用像 Plotly Express 这样的经典和新的可视化库，我试图发现东南亚城市国家 36.5 年的天气数据背后的模式。

Animated gif of maximum monthly recorded temperatures in Singapore from 1983 to June 2019.

缺少季节变化使许多人认为新加坡的天气是可预测的，不会改变。事实并非如此，气候变化让这个城市国家的天气变得更加不可预测。

我们开始感受到更暖和的天气和更强烈的风暴的影响。从地面来看，新加坡似乎在较早的时候变得更暖和了。

在许多日子里，早上 8 点迎接我的太阳感觉更像是我在上午晚些时候期待的东西。午后的火焰从未如此强烈。

在这个项目中，我将尝试使用经典的和新的可视化库，如 Plotly Express ，来展示新加坡不断变化的天气模式。

该项目的回购在此为。这个中帖的图表可以在这个笔记本中找到，而数据可以在这里和这里 (raw 版本)。

1。数据预处理

这个数据集是我能在新加坡公共领域找到的为数不多的详细的多年数据集之一。本文中的图表来自四个表格，这些表格针对少量缺失值进行了轻微处理，并针对额外的日期时间相关列进行了功能设计(参见笔记本此处)。

第一张表是来自气象局网站的一组每日记录，从 1983 年 1 月 1 日到 2019 年 6 月 30 日。虽然每日记录可以追溯到 1980 年，但 1980 年至 1982 年之间的记录大多不完整。出于一致性的考虑，我将所有四个表的共同起点设置为 1983 年。

第二张、第三张和第四张表格是来自新加坡政府数据机构网站的月度综合天气数据——分别为最高月气温、平均月气温和月降雨量。

本项目气象数据的原始来源可以在这里和这里找到。

2.暖气打开了——显示每日和每月的温度记录

根据新加坡国家气候变化秘书处的数据，从 1948 年到 2016 年，该国的年平均气温平均每十年上升 0.25 摄氏度。

该机构预测，未来日平均气温将上升 1.4 摄氏度至 4.6 摄氏度，在本世纪余下的时间里，从 2 月到 9 月，白天和夜晚将更加温暖。一组简单的折线图显示了我们的前进方向:

无论你怎么看，新加坡正在变暖，最高、最低和平均记录温度的趋势线都指向上方。

然而，在线图中经常会丢失细节，尤其是当彼此相邻分组时。在这种情况下，箱线图会很有用，它让我们深入了解多年来中值的分布以及异常值在哪里。

每个方框末端的水平线(或“胡须”)指的是当年各自的最小值和最大值，而中间的线指的是中间值。黑色的“钻石”是异常值。

一目了然，我们可以知道某一年的最高或平均温度范围，以及哪些年份的温度高于或低于正常温度。

可视化温度变化的另一个经典方法是使用热图:

左侧的热图显示的是月平均气温，描绘了几十年来更清晰的趋势，右侧较暗的斑块表明月平均气温在上升。中间较暗的区域也告诉你哪里最热。

右侧热图中最高月气温的模式有点难以解读。较暗的部分主要集中在 2 月至 5 月期间，尽管近年来从 2014 年开始，10 月份也有一片有趣的深红色。

2.1 实验#1:脊线图

随着更严肃的图表的出现，让我们看看更不常见的技术/库是否会产生更有趣的东西。

自从我在 2018 年末第一次遇到山脊线地块(或曾被称为 joyplots)以来，我一直很喜欢它们锐利、棱角分明的外观。它们看起来很棒，但我要诚实地说，在这种情况下，它们不一定像更简单的 Seaborn 图表那样清晰地呈现温度趋势。

2.2 实验#2:用 PLOTLY EXPRESS 制作 3D 动画图

Plotly Express 提供了大量有趣的功能，包括制作交互式 3D 动画图表的能力，如下图所示。诚然，这不是最清晰或最有效的方式来说明一种趋势，但它在视觉上令人兴奋，并在适当使用时为演示添加了一个有趣的新选项:

Medium 不便于将交互式图表嵌入到帖子中。要查看上图和下图，请点击查看完整的笔记本。

3.大雨将至——可视化每日和每月的降雨记录

在 1983 年 1 月至 2019 年 6 月期间，有 6399 天的降雨和 6931 天的干旱-大致持平。随着气候变化，预计会有更强烈的风暴。同样，让我们从经典和简单的图表开始，然后尝试不同的方法来显示每日和每月的降雨量数据。

上面的图表简单明了，总结了年降雨量并按年份分组。1997 年和 2015 年是年降雨量最少的年份，而 2007 年是年降雨量最多的年份。

但就年总降雨量而言，还没有持续的大幅上升或下降的迹象。让我们从更细的角度来看一下数据。

对于关于降雨量记录的第二个图表，我决定打破一些小规则，将 y 轴反转来模拟降雨的样子。我不确定这在“适当的”数据可视化中是否会遭到反对，但我觉得这是一种视觉上吸引人的数据呈现方式，也是数据本质的有机组成部分。

一眼看去，你就能知道异常值在哪里，是日降雨量还是月降雨量。

2011 年 1 月 30 日是过去 36 年来单日降雨量最大的一天。事实上，根据英国气象局对 2011 年天气的回顾，那是“自 1869 年有记录以来，一月份一天中最高的降雨量”。

转向右边的图表，我们看到 2006 年 12 月的月降雨量是该数据集中最大的。很快就可以看出，缺乏交互性是这种图表的一个问题，在这种图表中，您希望能够通过将鼠标悬停在特定数据点上来调出该数据点。在这种情况下，给图表添加注释会很麻烦。

同样，Plotly Express 图表在这种情况下很方便:

3.1 实验#3:条形图竞赛

最近，条形图比赛在社交媒体上变得非常流行。我用荣景上的模板为每月的降雨数据做了一个:

我明白为什么这样的图表在社交媒体上表现良好。但它们在传达趋势方面是否真的有效值得怀疑。你能把这个放在正式的报告里吗？

4.当风吹过的时候

由于地理位置的原因，风速在新加坡没有得到太多关注，这使得该岛免受热带气旋等严重风暴的影响。但快速浏览一下风力数据的历史模式，寻找潜在变化的迹象，仍然很有意思。

右边的图表表明，新加坡的平均风速在过去几十年里没有增加多少。在左图中，有趣的是看到了 2010 年以来记录的一系列强风。

过去 36 年中记录的最强阵风是在 2010 年 11 月 29 日，当时最大风速达到 90.7 公里/小时——约为同期记录的平均最大风速的 2.6 倍。

4.1 风&雨

我们自然也会把强风和暴雨联系在一起。让我们看看这两个条件是如何随时间变化的:较大的三角形表示降雨量较高，阴影较暗的三角形表示较新的降雨量，而阴影较浅的三角形则反映较早的降雨量记录。

这是使用 Plotly Express 复制的同一张图表，因此可以使用交互功能快速调用各个值:

5。一次又一次:矩阵面板比较

如果你想把天气数据按照月和日分解成一个面板矩阵，Plotly Express 有一个简洁的功能。

我为 1988 年、1998 年、2008 年和 2018 年的天气记录绘制了四个这样的矩阵，以比较四十年来的温度-降雨模式。较大和较暗的圆圈表示暴雨较大。

我在这里只包括了图表的截屏。对于完整的交互式图表，请查看笔记本这里，您可以将鼠标悬停在各个点上以获取更完整的数据。要放大感兴趣的特定区域，只需在图表上单击并拖动即可。

观想的可能性是无穷无尽的，这感觉像是在疲劳到来之前停下来的好时机。我很好奇你会用同样的数据集得出什么结论。请通过以下方式与我分享:

推特:@chinhon

领英:【https://www.linkedin.com/in/chuachinhon/

通过开放式银行和地理信息系统可视化消费行为

原文：https://towardsdatascience.com/visualising-spending-behaviour-through-open-banking-and-gis-9e7045674538?source=collection_archive---------34-----------------------

金融习惯历来是人们不太在意的东西，但随着信息量和可用工具的增加，一种新的金融控制态度正在透明的数字银行中越来越受欢迎。新型金融机构(如 Monzo、Starling、Revolut 和 N26)正在利用数字产品让他们的客户能够更好地访问和控制他们的支出。他们通过提供现代移动应用程序、实时通知、更好的安全性和开发人员 API 来实现这一目标，这些 API 允许任何有想法的人进行分析和产品化。

技术也在其他方面帮助了人类行为。当人们想起一件事或一段记忆时，他们通常指的是它发生的地方。当试图在手机上查找一张照片时，描述照片的拍摄地点往往比日期更容易，例如“我们在西班牙”或“这是在我格林威治的家里”。同样的人类行为也适用于财务决策和支出。一份写着“XDB 商品报 82.00 美元”的声明无助于解释交易背后的故事和决定，让人们感到困惑，拼命想知道这可能是什么。

我对在地图上探索金融交易的表现很感兴趣，这有助于回答关于消费发生在哪里的问题，并引发对所去过的地方的记忆。该地图与其他数据层相结合，还可以用于识别和确定历史消费习惯，寻找新的旅游地点，甚至通过位置识别欺诈和异常交易。

数据大小和范围

在这个实验中，我使用了 Monzo，它提供了一个非常全面的 API 来提取他们平台上的用户信息。收集这些数据需要非常明确的同意来收集和存储数据，因此对于这个练习，我只使用了我自己的数据，尽管可以构建一个可扩展的应用程序，并在其他用户允许的情况下分析他们的数据。

该数据集包含了过去 3 年我个人活期账户上的每一笔交易，记录刚刚超过 5000 条。数据被格式化为 JSON，并被结构化为一个对象数组，每个交易都包含时间戳、便士/美分整数形式的金额、货币、描述、类别、注释、附件(如收据)、元数据、结算信息和商家信息。商家信息包含名称、坐标、地址、Google Places ID、国家和一个近似的标志(在估计商家位置时进行标记)。

初步分析

该数据集提供了一个令人兴奋的机会，可以发现和分析更多关于我的消费习惯，并更好地了解 Monzo API 的功能。我创建了一个 JavaScript 程序来解析交易，并做一些非常基本的主题分类。

在数据集中，我发现大约 1/3 的交易花在外出就餐上，1/3 的交易花在喝咖啡上。咖啡馆代表了超过 400 笔交易，但总的来说消费相对较低，平均每次消费仅超过 3.5 英镑。金额最大的交易是工作支出，最昂贵的个人购买是购物，还有一个极端的异常值，是我去年完成的一个飞行员执照预付费飞行课程的第二高交易金额的近 5 倍。大多数交易发生在伦敦，但它们分布在五大洲，最孤立的交易发生在塔斯马尼亚的霍巴特。

Figure 1: All global transactions weighted by amount

三年间，通过该账户转移的资金总额达到了惊人的 20 万英镑(其中包括业务支出和向其他银行的转账)，仅包括个人支出的 9 万英镑。Monzo 不是我唯一的银行，这些数字之间的明显差异说明了使用原始数据得出有意义的结论的复杂性。业务支出不代表个人财务习惯，很容易扭曲形象；为了确保地图的准确性和丰富性，数据需要进行消毒。

初始实验

为了了解使用该数据集的可能性，并了解制图软件 QGIS 可能提供的限制和机会，我从 MapBox 加载了一个底图，并导入了所有 5000 个事务。

软件渲染速度很慢，而且所有的点都是重叠的。即使为每个类别的交易分配不同的颜色，地图也没有用，或者不容易从中得出任何有意义的东西。拥有太多的信息意味着项目重叠，并且没有像我最初希望的那样给出有用的结论。

Figure 2: All transactions layered on a base map with equal weighting

以这种方式呈现事务确实让我发现了数据集有趣的异常值和复杂性，如果不做这个实验，我是不会注意到这些的。网上购物在地理位置上尤其成问题(例如，AWS 显示美国的地理中心)。对于那些谷歌不知道他们的实际地址，而把商家放在国家地理中心的商家来说也是如此。

伦敦的默认中心是特拉法尔加广场，那里没有商店，所以可以肯定地说这些商户的位置是不准确的。

清理数据集

我修改了 JavaScript 应用程序来迭代事务，并执行一些过滤和规范化。首先，任何被归类为费用、账单、财务和存款的交易都将被删除，只留下个人费用。我还删除了商家不存在或没有地理信息的交易。我还重命名了一些键，使数据更容易在中处理，并简化了 JSON 结构，使其更容易转换为 CSV。这就建立了一个文件，其中只包含在实体商家中发生的交易，而不是称为“Monzo Sanitised Transactions”的业务费用。

Figure 3: The node app iterates over the dataset and writes a CSV file containing the location data

为了让数据更容易实验，我还创建了一个仅包含外出就餐交易的数据子集(称为“Monzo 外出就餐”)。这个较小的数据集解决了我在使用 QGIS 时遇到的一些性能问题。

我想使用地图标记的大小参数在可视化中反映交易的价值。我面临的另一个问题是，所有的交易金额大部分都是负数(因为这些代表的是钱从账户中流出的交易)。映射软件 QGIS 需要正整数标度，因此我通过调整清理公式将交易金额乘以-1 来修改金额值。这样做的一个后果是现在退款为负值；为了解决这个问题，我将最小表示值限制为零，确保只显示借记的交易。

Figure 4: Eating out transactions individually represented in Soho, London

我担心使用单个交易不能代表每个商家的合计总额和计数(这在统计上更有意义),也不能消除积分相互叠加的问题。我在 JavaScript 应用程序中创建了一个新功能，根据唯一的商家 id 对数据进行消毒，然后为每个商家创建一个交易总和和计数。

虽然该功能正确地减少了商家 ID 匹配的数据，但这种方法并不完美，因为商家数据是众包的，而且通常同一家商店不会共享相同的 ID。

Figure 5: Eating out transactions in London individually sized by amount

Figure 6: Eating out transactions in London aggregated by merchant and sized by amount

当汇总的数据被导入到地图上时，结果很有趣，因为从单个的可视化中几乎不可能理解或看到差异。极端的购买是非常异常的，很难看出小额消费之间的差异(价值和数量)。即使将转换曲线应用于该数据集，可视化仍然不如单个交易那样引人注目，因此我放弃了这种方法，并专注于其他更有效地可视化信息的方法。

地图图层

我最初使用 MapBox studio 创建了一个定制的基础层，以矢量格式在网络上提供服务。MapBox 是 Google maps 的一个很好的替代品，因为它可以在应用程序开发中使用。使用街道地图进行数据可视化的问题是地图在视觉上非常复杂。有许多颜色和标签分散了上层有趣数据的注意力。

我探索了一些其他地图视觉风格，并从野生动物地图中获得灵感，这些地图使用非常简单的线条和阴影来显示区域边界和重要位置。移除所有用于寻路的图层会对商家位置产生更大的影响，也更容易解释。

对于这些线，我选择了伦敦县的行政区和选区边界。这些形状文件可以在英国政府的开放数据库(data.gov.uk)上方便地获得，该数据库公布了其部门收集的开放数据，并提供了 2018 年边界测量的矢量形状文件。

转换坐标参考系统

使用政府底图时，我立即注意到的一个问题是，数据集不在同一个坐标参考系统中，并且地图本身存在偏差。数据由英国政府使用本地系统[OSGB36]生成，其中 Monzo 使用全球数字标准[WGS84]。我调整了数据层以使用基础层的 CRS。

成品地图

Figure 7: Map created using the sanitised data and base layers

最终的地图将 5 个支出类别分层，并对金额进行标准化，因此标记的大小代表支出的价值。

每个类别都用颜色表示，并且不透明，因此交易越频繁，颜色越丰富。兴趣点(住宅/工作地点)、铁路网络和一些有趣的异常值周围有清晰的聚类。

最大的集群并不令人惊讶，在伦敦市中心，外出就餐有大量的交易层层叠加，根据最初的分析，这大约是总交易数量的 1/3。并非巧合的是，这三个绿色集群都在我工作过的三个地方(肖尔迪奇、法灵顿和苏荷区)附近。很容易得出结论，我在工作地点附近和城市里的外出就餐上花了很多钱。

该图还显示了许多没有任何事务的空白区域。它显示了在过去的 3 年里我在伦敦西部度过的时间有多少，这可能是一个在那个地区尝试更多餐馆和商店的好机会。将这些信息与一个热门名单结合起来，可能是探索和核对伦敦和世界各地的好方法。

这种可视化也可能是抑制消费习惯的一种好方法，方法是随着时间的推移跟踪这些类别，并将目标游戏化，以取代用杂货外出就餐或减少总数来帮助省钱。

进一步发展

以这种方式向最终用户呈现商家数据可能是 Monzo 或 Google 验证商家位置并进一步众包关于商家正确定位的反馈的好方法。我有一个假设，人们思考他们在哪里/他们在哪里支付了一些东西，以这种方式呈现交易允许在人们质疑交易的地方询问离群值。它甚至可以帮助发现欺诈性交易，或通过提供交易发生地的急需上下文来减少假标记的欺诈。

我在我的数据集中发现了土耳其的一笔交易，我从未去过这个国家，但有一家在线商家在那里注册。我还在伦敦北部看到咖啡异常高的交易量，我很少去那里，但那里是商人总部所在地。这些例子表明，熟悉自己习惯的人可以如何对数据集做出贡献，并帮助创建更丰富、更准确的商家位置表示。

企业和政府可以从了解这些类别的位置中受益匪浅，以帮助提供信息:议会分区、企业价格设定/调整、瞄准“高流量”街道或路线、帮助个人管理他们的支出，甚至作为一种产品来帮助找到受欢迎的餐馆、景点或便利设施附近的住房。

事实证明，这项任务令人难以置信地发人深省，并开启了一种思考行为支出的新方式。在未来的版本中，我有兴趣在更大的用户群中继续这个实验，来比较人们之间的花费。探索其他参数(如一周中的某一天)如何影响消费者支出的变化和模式也是很有趣的。

Eating out locations by amount (pink) and frequency (blue)

版权和来源

英国政府，“国家统计”，开放数据[data.gov.uk]，2018 年

包含国家统计数据官方版权和数据库权利[2015]和包含地形测量数据官方版权和数据库权利[2015]

Monzo，“开发者 API”，开发者文档[api.monzo.com]，2019

MapBox，“工作室和地图 API”，[mapbox.com]，2019 年

图形和印刷品使用来自 Mapbox 和 OpenStreetMap 及其数据源的地图数据。要了解更多，请访问 https://www.mapbox.com/about/maps/的和 http://www.openstreetmap.org/copyright的。

帕克，交易数据，2019

使用真实世界的复杂网络可视化墨卡托图布局/嵌入。

原文：https://towardsdatascience.com/visualising-the-mercator-graph-layout-embeddings-using-a-real-world-complex-network-bf065c316b7a?source=collection_archive---------29-----------------------

A network of the Master Chemical Mechanism

制图领域长期以来一直使用投影将高维数据(即地球，扁球体)转换成平面表示。

在最近的一篇论文“ 墨卡托:揭示复杂网络的忠实双曲线嵌入(2019) *”中，*采用了将球形地球转换为圆柱形表示的相同数学方法，能够将恒定方位角映射为线性段，并应用它来产生无向和未加权网络内的节点嵌入。

我们的数据

我感兴趣的复杂网络是 2019 年北京空气质量活动中对流层(低层空气)化学的近显式表示。当使用传统的力定向或静电图形算法作图时，我们看到高度连接的物质形成了“毛团”。许多真实世界的图表就是这种情况。

Plotting the network using the Force Atlas algorithm.

应用墨卡托图布局

为了应用图表布局，我们使用https://github.com/networkgeometry/mercator提供的代码。这读入我们网络的边列表，并返回我们计算嵌入的极坐标。在绘制这些图时，我们得到了下图。

Plotted output of the Mercator embedding.

将输出转换成 JSON 文件

因为我们的绘图将在 Javascript 中完成，所以我们将嵌入输出转换成 JSON 格式，可以由可视化软件读取。

'''
To plot run python plot.py <filename>
This reads <filename>.edges and <filename>.inf_coord
'''import sys,json
import pandas as pd
name = sys.argv[1]edge= pd.read_csv(name+'.edge',comment='#',header=None,sep='\s+',index_col= None)[[0,1]]
edge.columns = 'source target'.split()df = pd.read_csv(name+'.inf_coord',comment='#',header=None,sep='\s+',index_col=0)
df.columns = 'k theta r'.split()save = {}
save['nodes'] = df.T.to_dict()
save['edges'] = edge.T.to_dict()json.dump(save,open(name+'.json','w'))

使用 D3.js 绘图

如果你对 Javascript 或 D3 不熟悉，我推荐你看看www.observablehq.com。这有许多关于如何制作图像和在图像中放置元素的例子。

对于那些能够分配点数的人，我们首先用d3.json('../data.json', data => {...})读入我们的数据，然后设置一个横跨半个页面的径向标尺:

size = Math.min(width,height)var r = d3.scaleLinear().domain(d3.extent(d3.values(data.nodes).map(d=>d.r))).range([0,size/2])

接下来，我们使用sine和cosine函数将极坐标从墨卡托输出转换成笛卡尔坐标。

node_data = {};
    d3.entries(data.nodes).forEach(d => {node_data[d.key] = {'x': r(d.value.r) * Math.cos(d.value.theta),
        'y':r(d.value.r) * Math.sin(d.value.theta)
      }});

最后，编写我们希望用来绘制节点的脚本

svg.selectAll(".node")
      .data(d3.values(data.nodes))
      .enter()
      .append("circle")
      .attr("r", 2)
      .attr('cx', d=> d.y)
      .attr('cy', d=> d.x)
      .style("fill", "steelblue")
      .style("opacity", 0.6)
      .attr('transform',`translate(${size/2},${size/2})`)

边缘捆绑

边捆绑是一种用于简化图中的边的技术。这里，边缘被模拟为柔性弹簧，如果满足一定的几何兼容性标准，它们会相互吸引。这通常用于减少可视化中链接的混乱。欲了解更多信息，请阅读和。

我们首先从D3-forcegebundling . js下载相关的库文件，并将其放入当前目录。从这里，我们可以使用脚本标签将它导入到我们的程序中:

<script type="text/javascript" src="d3-ForceEdgeBundling.js"></script>

我们现在可以引入边缘捆绑功能:

var fbundling = d3
      .ForceEdgeBundling()
      .step_size(.2)
      .compatibility_threshold(.70)
      .nodes(node_data)
      .edges(data.edges);const results = fbundling();

然后，我们遍历每个返回的边，并将其添加到我们的图像中:

var d3line = d3
      .line()
      .x(function(d) {
        return d['x'] ;
      })
      .y(function(d) {
        return d['y'];
      })
      .curve(d3.curveLinear);results.forEach(function(edge_subpoint_data,i) { svg
        .append("path")
        .attr("d", d3line(edge_subpoint_data,i))
        .style("stroke", "#222")
        .style("fill", "none")
        .style("stroke-width",0.25)
        .style("stroke-opacity", .39)
        .attr('transform',`translate(${size/2},${size/2})`)});

调整兼容性阈值

最后，我们可以调整兼容性阈值来改变不同边相互吸引的程度。这将把上面的线性图转换成下列之一。

钦佩结果

这就是我们的数据集的墨卡托图嵌入的边捆绑表示。

注意:所有图像都受版权保护。如果在任何地方使用，请引用“丹尼尔·埃利斯 2019”。

从 Python 可视化开始— Matplotlib

原文：https://towardsdatascience.com/visualization-in-python-matplotlib-c5c2aa2620a?source=collection_archive---------17-----------------------

对任何数据科学家或分析师来说，可视化数据都是一项重要的技能。这可以更好地了解数据的样子，允许检测模式或异常值的存在等。此外，它还是传达信息的一个有用工具，因为一个好的视觉效果可以很容易地告诉你很多文字不能告诉你的东西。古语有云，“一图胜千言”。这在数据科学/分析领域尤为重要。考虑到这一点，我写了这篇文章，通过 matplotlib 库向用户介绍 python 可视化的基础知识。

Photo by Luke Chesser on Unsplash

一幅画胜过千言万语

一如既往，第一步是导入所有需要的库。

import matplotlib.pyplot as plt
import numpy as np
from random import sample
%matplotlib inline

让我们为绘图练习生成一些数据，并绘制一个简单的线图。

x = np.linspace(0,10,20)#Generate 20 points between 0 and 10
y = x**2 # Create y as X squared
plt.plot(x,y) # Plot the above data

Figure 1

绘制上图只需要一行命令。虽然它很简单，但这并不意味着我们没有定制它的选项。

plt.plot(x, y, color='green', linestyle='--',
linewidth=2, alpha= 0.5)

Figure 2

在绘图命令控件内传递的参数用于:

颜色表示线条的颜色，甚至可以作为 RGB 十六进制代码给出

线条样式‘是你想要线条的样子，可以是’—‘或’—’对于虚线

线宽取整数输入表示线条的粗细

alpha 控制线条的透明度

有时一行可能还不够，您甚至需要指出哪些是确切的数据点，在这种情况下，您可以添加标记

plt.plot(x, y, marker = 'o', markerfacecolor = 'red', markersize = 5)

Fig 3

这块地有红色的圆形标记。这些标记可以通过修改它们的边界来进一步定制。

plt.plot(x, y, marker = 'o', markerfacecolor = 'red', markersize = 10, markeredgewidth = 2, markeredgecolor = 'black')

Fig 4

标记和以前一样，但现在它们有一个黑色的边界。

控制标记的参数有:

标记’表示您希望标记是什么形状，可以是’ o ‘、’ * ‘或’+’

标记面颜色表示标记的颜色

标记大小类似于线宽控制标记的大小

marked gewidth和’marked gecolor分别用于指定边界的粗细和颜色。

让我们将以上所有内容结合到一个图中:

Figure 5

不是最漂亮的情节，但你得到的想法。

虽然这涵盖了绘制数据的基础，但在标题、轴范围、图例等方面还有很多工作要做。

最简单的方法是使用 Matplotlib 的面向对象方法。

面向对象的方法

Matplotlib 有一个面向对象的 API，允许你创建图形和轴对象。然后可以有序地调用这些对象来执行诸如绘制数据或定制图形之类的功能。

fig, ax = plt.subplots()

Fig 6

上述命令返回图形和轴对象，并创建一个空图。

然后，这可用于重新创建上面的图，带有图和轴标题以及图例。

fig, ax = plt.subplots()#Create the objects
ax.plot(x,y,label = 'X squared')#The data to be plotted and legend
ax.set_title('Plot 1')#Plot title
ax.set_xlabel('X')#X axis title
ax.set_ylabel('Y')#Y axis title
ax.set_xlim(0,10)#Range of X axis
ax.set_ylim(0,110)#Range of Y axis
plt.legend()#Command to display the legend

Fig 7

上面的图(图 7)具有轴和图标题、图例以及 X 轴和 Y 轴的不同范围。

绘制多条线

假设你想比较两组不同的数据，例如，在同一个图中绘制多条线。在这种情况下，您只需要再添加一个 plot 命令。

fig, ax = plt.subplots()#Create the objects
ax.plot(x,y,label = 'X squared')#The data to be plotted and legend
ax.plot(x,x**3,label = 'X cubed')#The data to be plotted and legend
ax.set_title('Plot 1')#Plot title
ax.set_xlabel('X')#X axis title
ax.set_ylabel('Y')#Y axis title
ax.set_xlim(0,10)#Range of X axis
ax.set_ylim(0,110)#Range of Y axis
plt.legend()#Command to display the legend

Fig 8

另一种比较方法是并排显示两个不同的图。

fig, ax = plt.subplots(1,2)#Create the objects
ax[0].plot(x,y,label = 'X squared')#The data to be plotted and legend
ax[1].plot(x,x**3,label = 'X cubed')#The data to be plotted and legend
ax[0].set_title('Plot 1')#Plot title
ax[1].set_title('Plot 2')#Plot title
ax[0].legend()#Command to display the legend for plot 1
ax[1].legend()#Command to display the legend for plot 2
plt.tight_layout()#To ensure no overlap

Fig 9

这是通过首先在“subplot()”函数中传递绘图的数量来完成的。上面的(1，2)意味着应该有 1 行地块和 2 列地块，实际上意味着 2 个地块。对每一个图重复这些函数，并且‘tight _ layout()’命令确保没有重叠。这里的一个小变化是显示图例的命令。plot.legend()函数只显示一个图的图例，要同时显示两个图，需要为每个图指定图例。

第三种比较方法是使用插图。在一个更大的情节里，有一个更小的情节。

fig, ax = plt.subplots(figsize = (12,4))
axins = ax.inset_axes([0.1,0.6,0.4,0.3] )#Left, Bottom, Width, Heightax.plot(x,y,label='X squared')# Main plot
axins.plot(x,1/x,label='X inverse')# Inset plotax.set_xlabel('X')#X axis title
ax.set_ylabel('Y')#Y axis title
axins.set_xlabel('X')#X axis title
axins.set_ylabel('Y')#Y axis titleax.set_title('Main Plot')#Main plot title
axins.set_title('Inset Plot')# Inset plot title
ax.legend()#Legend for main plot
axins.legend()#Legend for inset plot

Fig 10

“subplots()”函数中的“figsize”参数允许更改图形的大小。“插入轴”功能用于创建插入图，同时指定位置和大小。前两个数字以百分比的形式指定绘图位置。在上面的例子中，前两个数字 0.1 和 0.6 指定绘图应该分别在 Y 轴和 X 轴的左侧 10%和上方 60%。最后两个数字 0.4 和 0.3 指定绘图应为主绘图宽度和高度的 40%和 30%。

您可能已经注意到主图的图例与插图重叠。虽然 matplotlib 会自动选择图例的最佳位置，但也可以使用“loc”参数手动移动。

fig, ax = plt.subplots(figsize = (12,4))
axins = ax.inset_axes([0.1,0.6,0.4,0.3] )#Left, Bottom, Width, Heightax.plot(x,y,label='X squared')
axins.plot(x,1/x,label='X inverse')ax.set_xlabel('X')#X axis title
ax.set_ylabel('Y')#Y axis title
axins.set_xlabel('X')#X axis title
axins.set_ylabel('Y')#Y axis titleax.set_title('Main Plot')
axins.set_title('Inset Plot')
ax.legend(loc = 4)
axins.legend()

Fig 11

“loc”参数接受 0 到 10 之间的输入，对应于图中的位置。0 表示 Matplotlib 将选择可能的最佳位置，这是默认选项，所有其他整数对应于绘图中的一个位置。在这里，我将“4”传递给“loc”参数，这意味着图例位于右下角。

我将介绍的最后一个定制是改变剧情背景。

fig, ax = plt.subplots(figsize = (12,4))
axins = ax.inset_axes([0.1,0.6,0.4,0.3] )#Left, Bottom, Width, Heightax.plot(x,y,label='X squared')
axins.plot(x,1/x,label='X inverse')ax.set_xlabel('X')#X axis title
ax.set_ylabel('Y')#Y axis title
ax.grid(True)#Show grid
axins.set_xlabel('X')#X axis title
axins.set_ylabel('Y')#Y axis title
axins.grid(color='blue', alpha=0.3, linestyle='--', linewidth=2)#Grid modificationsax.set_title('Main Plot')
axins.set_title('Inset Plot')
ax.legend(loc = 4)
axins.legend()

Fig 12

这里的主图有默认的网格，只需调用 grid()函数就可以创建它。

网格线也可以像地块线一样进行修改。这些修改可以在插图中看到。与主图相比，图中的网格线具有不同的颜色、样式和宽度。

特殊情节

除了简单的线图，matplotlib 还可以创建许多不同类型的图。

散点图:

fig, ax = plt.subplots()
ax.scatter(x,y,label='X squared')
ax.set_xlabel('X')#X axis title
ax.set_ylabel('Y')#Y axis title
ax.set_title('Plot')
ax.legend()

Fig 13

直方图:

x = sample(range(1,100), 60)
fig, ax = plt.subplots()
ax.hist(x)
ax.set_title('Histogram')

Fig 14

柱状图

x = np.linspace(0,10,11)
y = x**2
fig, ax = plt.subplots()
ax.bar(x, y)
ax.set_title('Bar plot')

Fig 15

这涵盖了 matplotlib 可用的一些基本绘图和自定义。虽然 matplotlib 有高级绘图和统计绘图的选项，但最好使用 Seaborn 来实现。

Seaborn 是一个基于 matplotlib 构建的统计数据可视化库。我将在以后的文章中介绍它，在这里学到的基础知识也将有助于在 Seaborn 建造地块。

你也可以在 LinkedIn 上与我联系

使用 Matplotlib 实现数据可视化

原文：https://towardsdatascience.com/visualization-library-in-python-matplotlib-470a2e631d73?source=collection_archive---------35-----------------------

在我之前的故事中，我已经描述了 python 中两个最重要的 Python 库: Numpy 和 Pandas 。今天我将讲述 Matplotlib，它是 python 中最流行和最广泛使用的可视化库。不再耽搁，我们开始吧。

[Matplotlib](https://www.numpy.org)是一个 Python 2D 绘图库，它以多种硬拷贝格式和跨平台的交互环境生成出版物质量数字。这是一个流行的 python 绘图库，可以让您控制图形的各个方面。它被设计成有一种类似于MATLAB图形绘制的感觉。它可以提供大量的优势，如简单的绘图容易开始，支持自定义标签和文本，对图形中每个元素的良好控制，多种格式的高质量输出，非常可定制等。

要在您的系统中安装Matplotlib库并进一步了解 python 基础知识，您可以点击以下链接:

[## 机器学习和数据分析—仁荷大学(第一部分)

第 1 章:基本 python 和安装

towardsdatascience.com](/machine-learning-and-data-analysis-inha-university-part-1-be288b619fb5)

现在要在程序中使用Matplotlib，我们需要导入模块。为了方便起见，一般将Matplotlib包定义为plt的缩写。但是您可以使用任何想要的东西来导入它。

**import matplotlib.pyplot as plt** # importing matplotlib**x=pd.Series([1,2,3,4])** # create pandas series **y=2*x+3** # define y **plt.plot(y)** # Functional plot **plt.show()** # show plot

输出:

当使用 Jupyter 笔记本作为模拟环境时，我们需要在命令行中提到%matplotlib inline，它允许查看 Jupyter 笔记本内部的情节。

**import matplotlib.pyplot as plt** # importing matplotlib
**import numpy as np  **              # importing numpy
**%matplotlib inline** # see plot in Jupyter notebook
**x=np.arange(0,10,0.5)** # define x **y1=2*x+3** # define y1 **y2=3*x** # define y2 **plt.figure(1,figsize=(12,12))** # create a figure object
**plt.subplot(331)** # divide the figure 3*3, 1st item
**plt.plot(x,y1,'r-')** # Functional plot
**plt.title('Line graph')** # define title of the plot
**plt.subplot(332)**                  # divide the figure 3*3, 2nd item
**plt.plot([1,3,2,7],[10,20,30,40])** # Functional plot
**plt.title('Two-dimensional data')** # define title of the plot
**plt.subplot(333)** # divide the figure 3*3, 3rd item
**plt.plot([10,20,30,40],[2,6,8,12], label='price')** # set label name
**plt.axis([15,35,3,10])** # axis scale - x:15-35, y:3-10
**plt.legend()** # show legends on plot
**plt.title('Axis scaled graph')** # define title of the plot
**plt.subplot(334)** # divide the figure 3*3, 4th item
**plt.plot(x,y1,'r-',x,y2,'b--')**    # y1 - red line, y2 - blue line
**plt.title('Multi line plot')** # define title of the plot
**plt.subplot(335)**                  # divide the figure 3*3, 5th item
**x=np.random.normal(5,3,1000)**      # normal distribution - mean: 5, variance: 3, number of data: 1000
**y=np.random.normal(5,3,1000)**      # normal distribution - mean: 5, variance: 3, number of data: 1000
**plt.scatter(x,y,c='k')** # Functional plot
**plt.title('Scatter plot')**
**plt.subplot(336)**                  # divide the figure 3*3, 6th item
**player=('Ronaldo','Messi','Son')**
**goal=[51,48,25]**
**plt.bar(player,goal,align='center',color='red',width=0.5)** 
**plt.title('Bar plot')** # define title of the plot **plt.show()** # show plot

Matplotlib 中的 3D 绘图

为了启动 matplotlib 中的 3D 绘图，我们需要从mpl_toolkits.mplot3d导入Axes3D。

**import numpy as np** # importing numpy **import matplotlib.pyplot as plt** # importing matplotlib **from mpl_toolkits.mplot3d import Axes3D** # importing Axes3D, 3d plot **fig = plt.figure()** # create a figure object **ax = Axes3D(fig)** # defining 3d figure ax **X = np.arange(-4, 4, 0.25)** # defining X **Y = np.arange(-4, 4, 0.25)** # defining Y **X, Y = np.meshgrid(X, Y)    
R = np.sqrt(X ** 2 + Y ** 2)
Z = np.sin(R)
ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=plt.cm.hot)**#plot **ax.contourf(X, Y, Z, zdir='z', offset=-2, cmap=plt.cm.hot)
ax.set_zlim(-2, 2)** # set z-axes limit **plt.show()**

输出:

当使用 matplotlib 执行子情节时，我们需要为每个情节保持紧凑的布局，以避免图形之间的混乱。我们可以保持正方形图形尺寸来避免这个问题，或者我们可以使用tight_layout()。

**fig,ax = plt.subplots(nrows=3,ncols=3)
plt.tight_layout()
plt.show()**

输出:

在 Matplotlib 中保存图形

Matplotlib 可以生成 *PNG、JPG、EPS、SVG、PGF、*和 PDF 格式的高质量图形，我们可以用 matplotlib 保存图形。我们还可以将图形保存在我们想要的文件位置。我们可以按照下面的例子，图保存在一个目标文件位置。

**import matplotlib.pyplot as plt** # importing matplotlib **%matplotlib inline** # see plot in Jupyter notebook **x = [0, 2, 4, 6]** # define x **y = [1, 3, 4, 8]** # define y **plt.plot(x,y)** # functional plot **plt.xlabel('x values')** # define x label **plt.ylabel('y values')** # define y label **plt.title('plotted x and y values')** # define title **plt.legend(['line 1'])** # define legend# save the figure **plt.savefig('plot.png', dpi=300, bbox_inches='tight')
fig.savefig('E:\Bioinformatics/foo.png')****plt.show()**

输出:

为了保存其他格式的数字，我们需要用它来代替png。如果你正在使用 jupyter 笔记本，并且想要将任何图形保存到另一个想要的文件夹中，那么你可以遵循命令fig.savefig("E:\Bioinformatics/foo.png"，其中 foo 是图形的名称。

图例

为了在 Matplotlib 中提到图例，我们可以使用ax.legend(),其中 ax 是图形的名称。我们还可以在ax.plot()中定义标签的名称。为了更好的理解，我们可以看下面的例子。

**import matplotlib.pyplot as plt** # importing matplotlib **%matplotlib inline** # see plot in Jupyter notebook **x = np.array([0, 2, 4, 6])** # define x **fig = plt.figure()** # create a figure object **ax = fig.add_axes([0,0,1,1])** # axes with (L,B,W,H) value **ax.plot(x, x**2, label = 'X2', color='red')** # functional plot **ax.plot(x, x**3, label = 'X3', color='black')** # functional plot **ax.set_xlim([0, 5])** # set x-axes limit **ax.set_ylim([0,100])** # set y-axes limit **ax.legend()** #show legend **plt.show()** # show plot

输出:

我们可以估计传说的位置。ax.legend(loc=0)为传说中的最佳位置，loc=10为中心位置。我们也可以定义位置。十六进制代码也可用于定义图中的color。我们还可以使用set_xlim([0,5])和set_ylim([0,100])设置 x 轴和 y 轴的极限，其中提到了极限的下限和上限。

非常感谢你的时间。你可以关注我的其他教程简介。我已经发表了机器学习和数据分析系列的 4 个部分，这是基于 Inha 大学提供的研究生课程。你可以按照**Part-1，Part-2，Part-3， Part-4 来获得用 Python 进行机器学习移动的起始思路。非常感谢任何建议或批评。**

Part-1:python 基础及安装
Part-2:第二章:Python 数据结构—数据类型
Part-3:Python 中的控制语句(循环)
Part:4:Python 函数【T39

参考链接:

1. ****Matplotlib cheet sheet:https://S3 . amazonaws . com/assets . data camp . com/blog _ assets/Python _ Matplotlib _ Cheat _ sheet . pdf
2. ****教程:https://www . tutorialspoint . com/matplotlib/matplotlib _ Tutorial . pdf

3.http://courses . csail . MIT . edu/6.867/wiki/images/3/3f/Plot-python . pdf

4.https://riptutorial.com/Download/matplotlib.pdf

来自原始 Twitter 数据的信息可视化——第 1 部分

原文：https://towardsdatascience.com/visualization-of-information-from-raw-twitter-data-part-1-99181ad19c?source=collection_archive---------4-----------------------

让我们探索一下我们可以从原始 Twitter 数据中轻松检索到什么样的信息！

大家好！在之前的文章中，我们探讨了如何使用 Python 和两个 Twitter APIs 高效地下载数据:下载实时生成的推文的流 API ，以及下载用户时间线和关注者等历史信息的 REST API 。

这篇文章是两篇文章中的第一篇，将致力于从使用 Twitter 流媒体 API 下载的数据中提取酷的可视化和信息，没有任何类型的机器学习或任何其他复杂的算法。

放松放松，让我们开始吧！

1.收集数据:

首先，我们需要收集我们想要可视化信息的数据。我们将使用流 API 来收集关于某个主题的 tweets，这可以通过使用 stream 对象的 filter 参数来查询特定的 hashtags 来完成。

如果您对此不熟悉，我建议您看看我关于如何使用流式 API 下载数据的帖子:

[## 使用流式 API 从 Twitter 下载数据

在这篇文章中，我们将介绍如何使用流媒体 API 来获取包含特定单词或标签的推文，以及如何…

medium.com](https://medium.com/@jaimezornoza/downloading-data-from-twitter-using-the-streaming-api-3ac6766ba96c)

基本上，在 tweet 下载脚本中类似这样的行上面

l = StdOutListener()    auth = OAuthHandler(consumer_key, consumer_secret)    auth.set_access_token(access_token, access_token_secret)    stream = Stream(auth, l)    stream.filter(track=tracklist)

包括以下代码行:

tracklist = ['#HASHTAG1', '#HASHTAG2', '#HASHTAG3']

并将 #HASHTAG1、#HASHTAG2 和#HASHTAG3 的值更改为与您想要收集数据的主题相关的 HASHTAG。这个列表中可以包含或多或少的标签。

一旦脚本准备好了，就运行它，并以这种方式将其输出传输到一个. txt 文件，就像前面提到的帖子中描述的那样:

Twitter _ downloader . py>Twitter _ data . txt

让它运行一段时间，或者设置最大数量的推文，就这样，你的数据准备好被分析了！

2.准备数据:

现在我们的数据已经准备好了，让我们看看我们可以从中获得什么样的见解！为了这篇文章，我下载了大约两天的关于英国退出欧盟的推文，在 API 中查询带有英国退出欧盟相关标签的推文，如英国退出欧盟、英国退出欧盟、人民投票或游行。

打开 Jupyter 笔记本，开始编码:

首先，像往常一样，我们需要导入分析和可视化所需的库:

#Import all the needed libraries
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import json
import seaborn as sns
import re
import collections
from wordcloud import WordCloud

然后，我们将读取我们收集的数据并对其进行处理。请记住，流式 API 的输出是每个 tweet 的 JSON 对象，其中有许多字段可以提供非常有用的信息。在下面的代码块中，我们从。txt 文件，它们存储在:

#Reading the raw data collected from the Twitter Streaming API using #Tweepy. 
tweets_data = []
tweets_data_path = 'Brexit_tweets_1.txt'
tweets_file = open(tweets_data_path, "r")
for line in tweets_file:
    try:
        tweet = json.loads(line)
        tweets_data.append(tweet)
    except:
        continue

为此，您必须将字符串 tweets_data_path 更改为存储数据的文档的名称。我还建议你在存储下载的 tweets 的同一个文件夹中创建笔记本，这样你在加载数据时就不必考虑任何相对路径。

下载数据时，可能会出现连接问题或其他类型的错误，所以在。在我们存储推文的地方，可能有一些行应该是推文，但却是错误代码。要消除它们，请在阅读完。txt 文件。

#Error codes from the Twitter API can be inside the .txt document, #take them off
tweets_data = [x for x in tweets_data if not isinstance(x, int)]

现在，让我们看看我们收集了多少条推文:

print("The total number of Tweets is:",len(tweets_data))

以我为例，我下载了133030推文。

好了，现在我们已经读了。txt 文件，并在笔记本中准备好 JSON 格式的 tweets，我们将实现一些函数来将这些 JSON 对象的一些参数映射到 Pandas dataframe 的列，从现在开始，我们将在那里存储 tweets 。

首先，我们将创建一个函数，允许我们查看选择的 tweet 是否是一个 retweet 。这是在中通过评估 JSON 对象是否包含名为’retweed status '的字段来完成的。如果推文是转发，这个函数返回一个布尔值 True，否则返回 False。

#Create a function to see if the tweet is a retweetdef is_RT(tweet):
    if 'retweeted_status' not in tweet:
        return False      
    else:
        return True

现在，我们将做一些类似的事情来评估下载的推文是否是对其他用户的推文的回复。同样，这是通过检查 JSON 对象中是否缺少某些字段来完成的。我们将使用“in _ reply _ to _ screen _ name”字段，这样除了查看推文是否是响应之外，我们还可以查看推文正在响应哪个用户。

#Create a function to see if the tweet is a reply to a tweet of #another user, if so return said user. def is_Reply_to(tweet):
    if 'in_reply_to_screen_name' not in tweet:
        return False      
    else:
        return tweet['in_reply_to_screen_name']

最后，tweet JSON 对象包括一个’ source '字段，它是发布 tweet 的设备或应用程序的一种标识符。Twitter 没有提供如何将这个源字段映射到实际设备的详细指南，所以我手动列出了我认为源信息可以映射到的列表。

#Create function for taking the most used Tweet sources off the #source column def reckondevice(tweet):
    if 'iPhone' in tweet['source'] or ('iOS' in tweet['source']):
        return 'iPhone'
    elif 'Android' in tweet['source']:
        return 'Android'
    elif 'Mobile' in tweet['source'] or ('App' in tweet['source']):
        return 'Mobile device'
    elif 'Mac' in tweet['source']:
        return 'Mac'
    elif 'Windows' in tweet['source']:
        return 'Windows'
    elif 'Bot' in tweet['source']:
        return 'Bot'
    elif 'Web' in tweet['source']:
        return 'Web'
    elif 'Instagram' in tweet['source']:
        return 'Instagram'
    elif 'Blackberry' in tweet['source']:
        return 'Blackberry'
    elif 'iPad' in tweet['source']:
        return 'iPad'
    elif 'Foursquare' in tweet['source']:
        return 'Foursquare'
    else:
        return '-'

好吧！创建完所有这些函数后，我们就可以将我们的 tweets 传递到一个数据帧中，以便于处理。请注意，从 JSON 对象中提取的 dataframe 的一些列不需要定制函数，因为我们只是从 JSON 中获取这些列的原始数据。然而，数据框架的一些列确实需要一些进一步的解释。

dataframe 的’ text ‘列要么用 JSON 对象的普通’ text 字段填充，要么用’ extended_tweet’ 全文填充。这样做是因为有些 tweets 的文本长度在 140 到 280 个字符之间，对于它们来说，JSON 对象的’ text '字段并不包含全部文本。

#Convert the Tweet JSON data to a pandas Dataframe, and take the #desired fields from the JSON. More could be added if needed.tweets = pd.DataFrame()
tweets['text'] = list(map(lambda tweet: tweet['text'] if 'extended_tweet' not in tweet else tweet['extended_tweet']['full_text'], tweets_data))
tweets['Username'] = list(map(lambda tweet: tweet['user']['screen_name'], tweets_data))
tweets['Timestamp'] = list(map(lambda tweet: tweet['created_at'], tweets_data))
tweets['lenght'] = list(map(lambda tweet: len(tweet['text']) if'extended_tweet' not in tweet else len(tweet['extended_tweet']['full_text']) , tweets_data))
tweets['location'] = list(map(lambda tweet: tweet['user']['location'], tweets_data))
tweets['device'] = list(map(reckondevice, tweets_data))
tweets['RT'] = list(map(is_RT, tweets_data))
tweets['Reply'] = list(map(is_Reply_to, tweets_data))

dataframe 的*‘Username*’列描述了发布推文的用户，所有其他列都是不言自明的。

如果我们看一下数据帧的头部，它应该是这样的:

tweets.head()

厉害！我们的数据框架已经建立，我们已经准备好探索数据了！

3.数据分析和可视化

首先，我们将探索可以使用流式 API 检索的不同 tweet 类别。让我们看看有多少条转发被转发例如:

#See the percentage of tweets from the initial set that are #retweets:RT_tweets = tweets[tweets['RT'] == True]
print(f"The percentage of retweets is {round(len(RT_tweets)/len(tweets)*100)}% of all the tweets")

对我来说转发量占所有推文的 73%。

这提供了一些关于 Twitter 如何工作的有趣信息:大多数用户不发布自己的内容，而是转发其他用户的内容。

如果我们获取 RT_tweets 数据帧并打印其头部，我们会得到如下结果:

RT_tweets.head()

从这个数据帧中，我们可以看到当推文被转发时，流媒体 API 返回的推文的文本结构。这种格式如下:

" RT @InitialTweetingUser: Tweet 文本"

其中开头的 RT 表示该 tweet 为 retweet ， @InitialtweetingUser 为发布原始 tweet 的账户的 Twitter 用户名，Tweet Text 为所述初始 Tweet 的文本。

通过我们创建的回复栏，我们还可以看到从流媒体 API 下载的条推文中有多少条是对另一个用户的条推文的回复:

#See the percentage of tweets from the initial set that are replies #to tweets of another user:Reply_tweets = tweets[tweets['Reply'].apply(type) == str]
print(f"The percentage of retweets is {round(len(Reply_tweets)/len(tweets)*100)}% of all the tweets")

对我来说，回复的百分比大约是所有推文的 7%。

同样，如果我们看一下这个 Reply_tweets 数据帧，我们可以看到流式 API 返回的回复的结构:

正如我们所看到的，这些回复具有以下格式:

" @InitialTweetingUser 回复文本"

其中 @InitialTweetingUser 是发布被回复推文的用户，回复文本是回复。

现在让我们看看有提及但没有被转发的推文的百分比。请注意，这些推文包括了之前的回复推文。

#See the percentage of tweets from the initial set that have #mentions and are not retweets:mention_tweets = tweets[~tweets['text'].str.contains("RT")  & tweets['text'].str.contains("@")]
print(f"The percentage of retweets is {round(len(mention_tweets)/len(tweets)*100)}% of all the tweets")

对我来说，这占了全部推文的 11%。带有提及但未回复或转发的推文只是在文本中间某处包含所述提及的推文，例如:

“我们的工作假设仍然是英国将在 3 月 29 日离开”，英国退出欧盟的@EU_Commission spox 说。动词“remain”用得好。

最后，让我们看看有多少推文只是纯文本推文，没有提及或转发:

#See how many tweets inside are plain text tweets (No RT or mention)plain_text_tweets = tweets[~tweets['text'].str.contains("@")  & ~tweets['text'].str.contains("RT")]
print(f"The percentage of retweets is {round(len(plain_text_tweets)/len(tweets)*100)}% of all the tweets")

对我来说，这是所有推文 的 15%左右。

让我们将所有这些类别绘制成图表，以便更好地比较它们的比例:

#Now we will plot all the different categories. Note that the reply #tweets are inside the mention tweetslen_list = [ len(tweets), len(RT_tweets),len(mention_tweets), len(Reply_tweets), len(plain_text_tweets)]
item_list = ['All Tweets','Retweets', 'Mentions', 'Replies', 'Plain text tweets']
plt.figure(figsize=(15,8))
sns.set(style="darkgrid")
plt.title('Tweet categories', fontsize = 20)
plt.xlabel('Type of tweet')
plt.ylabel('Number of tweets')
sns.barplot(x = item_list, y = len_list,  edgecolor = 'black', linewidth=1)

plt.show()

厉害！让我们来看看哪些是最常用的标签和最常被提及的用户:

#To see the most used hashtags.hashtags = []
hashtag_pattern = re.compile(r"#[a-zA-Z]+")
hashtag_matches = list(tweets['text'].apply(hashtag_pattern.findall))hashtag_dict = {}
for match in hashtag_matches:
    for singlematch in match:
        if singlematch not in hashtag_dict.keys():
            hashtag_dict[singlematch] = 1
        else:
            hashtag_dict[singlematch] = hashtag_dict[singlematch]+1

为此，我们将使用正则表达式(包含在 Python 库 re 中)创建一个模式来检测文本中的标签。然后，我们将创建一个包含所有找到的 hashtag 的字典，其中键是 hashtag 文本，值是 hash tag 被发布的次数。

#Making a list of the most used hashtags and their valueshashtag_ordered_list =sorted(hashtag_dict.items(), key=lambda x:x[1])
hashtag_ordered_list = hashtag_ordered_list[::-1]#Separating the hashtags and their values into two different lists
hashtag_ordered_values = []
hashtag_ordered_keys = []
#Pick the 20 most used hashtags to plot
for item in hashtag_ordered_list[0:20]:
    hashtag_ordered_keys.append(item[0])
    hashtag_ordered_values.append(item[1])

之后，我们将根据值对字典进行排序，并将值和标签分成两个不同的列表。通过这样做，我们现在可以绘制出 20 个最常用的标签，以及它们出现的次数:

#Plotting a graph with the most used hashtagsfig, ax = plt.subplots(figsize = (12,12))
y_pos = np.arange(len(hashtag_ordered_keys))
ax.barh(y_pos ,list(hashtag_ordered_values)[::-1], align='center', color = 'green', edgecolor = 'black', linewidth=1)
ax.set_yticks(y_pos)
ax.set_yticklabels(list(hashtag_ordered_keys)[::-1])
ax.set_xlabel("Nº of appereances")
ax.set_title("Most used #hashtags", fontsize = 20)
plt.tight_layout(pad=3)
plt.show()

从该图中可以清楚地看到，#英国退出欧盟是使用最多的标签，这是非常明显的，因为它是用于下载英国退出欧盟话题推文的标签之一。可以用这些信息制作的另一个很好的可视化表示是使用 Wordcloud Python 库的 Wordcloud。单词云是不同单词的拼贴，这些单词具有相应的数值(如出现的次数)，并根据该值进行缩放:具有最高值的单词将是拼贴中最大的单词。

#Make a wordcloud plot of the most used hashtags, for this we need a #dictionary 
#where the keys are the words and the values are the number of #appearanceshashtag_ordered_dict = {}
for item in hashtag_ordered_list[0:20]:
    hashtag_ordered_dict[item[0]] = item[1]
wordcloud = WordCloud(width=1000, height=1000, random_state=21, max_font_size=200, background_color = 'white').generate_from_frequencies(hashtag_ordered_dict)
plt.figure(figsize=(15, 10))
plt.imshow(wordcloud, interpolation="bilinear")
plt.axis('off')

plt.show()

Wordcloud representation of the most used hashtags

看起来很酷吧？现在让我们对提及做同样的事情。

#Now we will do the same with the mentions: mentions = []
mention_pattern = re.compile(r"@[a-zA-Z_]+")
mention_matches = list(tweets['text'].apply(mention_pattern.findall))mentions_dict = {}
for match in mention_matches:
    for singlematch in match:
        if singlematch not in mentions_dict.keys():
            mentions_dict[singlematch] = 1
        else:
            mentions_dict[singlematch] = mentions_dict[singlematch]+1

同样，我们使用正则表达式来构建一个提及的模式，并创建一个字典，其中的键是被提及的用户，值是他们被提及的次数。考虑到这种提及模式也将从转发和回复中获取提及，因此该字典还将包括未被明确提及的用户，以及其帖子已被转发或回复的用户。

#Create an ordered list of tuples with the most mentioned users and #the number of times they have been mentionedmentions_ordered_list =sorted(mentions_dict.items(), key=lambda x:x[1])
mentions_ordered_list = mentions_ordered_list[::-1]#Pick the 20 top mentioned users to plot and separate the previous #list into two list: one with the users and one with the valuesmentions_ordered_values = []
mentions_ordered_keys = []
for item in mentions_ordered_list[0:20]:
    mentions_ordered_keys.append(item[0])
    mentions_ordered_values.append(item[1])

现在，如果我们画出这些结果:

fig, ax = plt.subplots(figsize = (12,12))
y_pos = np.arange(len(mentions_ordered_values))
ax.barh(y_pos ,list(mentions_ordered_values)[::-1], align='center', color = 'yellow', edgecolor = 'black', linewidth=1)
ax.set_yticks(y_pos )
ax.set_yticklabels(list(mentions_ordered_keys)[::-1])
ax.set_xlabel("Nº of mentions")
ax.set_title("Most mentioned accounts", fontsize = 20)

plt.show()

由此可以看出谁是被提及最多的账号:@theresa_may，Theresa May 的官方账号。我们还可以在这张图表中看到其他政治人物，如@jeremycorbyn(杰里米·科尔宾)或@Anna_Soubry(安娜·苏布里)，属于政党的账户(@英国工党，@保守党)，新闻来源(@BBCNews，@BBCPolitics，@SkyNews)，以及不同的记者(@georgegalloway)

这种见解可能非常有用，在未来的帖子中，我们将探索如何使用不同的 Twitter 交互来创建网络，并查看这些最常提到的用户在这些网络中的角色。

至于标签，让我们也做一个词云表示:

#Make a wordcloud representation for the most mentioned accounts toomentions_ordered_dict = {}
for item in mentions_ordered_list[0:20]:
    mentions_ordered_dict[item[0]] = item[1]
wordcloud = WordCloud(width=1000, height=1000, random_state=21, max_font_size=200, background_color = 'white').generate_from_frequencies(mentions_ordered_dict)
plt.figure(figsize=(15, 10))
plt.imshow(wordcloud, interpolation="bilinear")
plt.axis('off')

plt.show()

Worcloud representation of the most mentioned users

结论

我们已经探索了一些有趣的可视化，可以从原始 Twitter 数据中获得，而无需任何复杂的算法，并且还研究了 Twitter 的流媒体 API 的响应格式。

在下一篇文章中，我们将继续一些其他很酷的可视化技术:查看哪些用户发布了最多的推文，他们是机器人的可能性，我们还将创建推文发布的时间序列，检查产生推文的设备，并获得一些进一步的见解。

更多牛逼的自然语言处理和机器学习资源，请查看本博客: 如何学习机器学习 。

感谢您的阅读，祝您愉快，再见！

可视化恒温器折扣数据

原文：https://towardsdatascience.com/visualize-data-fast-watson-studio-ae1ec63e9b8f?source=collection_archive---------27-----------------------

github repo 上的逐步说明。

正如一些读者所知，通过提供设备折扣，智能恒温器对美国消费者更具吸引力。你可能不知道的是，恒温器的折扣根据邮政编码的不同而不同。这篇博客调查了美国哪些地区的回扣较高或较低，并直观地展示了结果。对于这个分析，我使用了 IBM 的 Watson Studio ，它使得与数据的可视化交互变得简单而快速。

数据分布

让我们从数据分布开始，这将为我们提供所有可能值的概述，以及它们出现的频率。用视觉术语来说，这意味着绘制恒温器折扣的直方图。为简单起见，我们可以使用从更大的数据集中提取的 1k 行的统一样本。

Watson Studio 中的数据提炼工具可以让您轻松地绘制柱状图，以及许多其他一次可能涉及多列的图表(散点图、时间序列等)。

Distribution of Thermostat Rebates

请注意，超过一半的恒温器折扣在 100 美元到 120 美元之间。我注意到只有少数邮政编码有超过 140 美元或低于 60 美元的折扣，这激起了我的兴趣。我决定在一张地图上标出获得最低和最高折扣的地区。幸运的是，数据已经包含了经度和纬度信息，所以一旦我指定了从最低(蓝色)到最高(红色)的色谱，我就可以将数据放在州地图上:

我注意到北加州的回扣比美国其他大多数地区都低。我还注意到，大多数最大的回扣都在得克萨斯州。老实说，我还是不确定为什么会这样。如果你有猜测，一定要让我知道。

Watson Studio 中的数据提炼工具有地图，您可以使用它来放置经度/纬度数据，它让您可以使用数据集的任何列轻松配置色谱。

与人口统计特征的相关性

为了更深入地了解恒温器折扣分布，我做了一个按邮政编码连接，以引入额外的人口统计特征，如家庭收入中值和平均值，以及人口规模。这些邮政编码的人口统计特征似乎都与恒温器折扣没有线性关系。唯一强相关的是家庭收入的平均值和中值，这并不奇怪。

Correlation Plots Created with Data Refinery.

更多图表可供探索

除了直方图和地图，Watson Studio 中的数据提炼工具还提供了广泛的可视化选择，包括用于可视化高维数据的 t-SNE:

Chart Options in Data Refinery (part of Watson Studio)

github repo 上的逐步说明。

特别感谢史蒂夫·摩尔对这篇文章的大力反馈。

推特:@ castan LinkedIn:@jorgecasta

基于 t-SNE 的可视化降维

原文：https://towardsdatascience.com/visualize-high-dimensional-data-fast-watson-studio-ebad7e7e1b6a?source=collection_archive---------13-----------------------

github repo 上的分步说明

t-SNE on MNIST Database of Handwritten Digits

不需要编码，Python 或 R。只需插入您的高维数据，并使用沃森工作室中的数据提炼工具将其可视化。不要误解我，我喜欢用 Python 和 R 编写代码，但是当涉及到快速可视化数据时，我只是使用数据精炼。

重要的事情先来。在这篇博客中，我提到的高维数据是指数据集的特征数量，而不一定是指观察值的数量。图像由大量像素组成，这些像素可以被投影到二维空间。但是为什么要投影到二维呢？将代表相同对象的图像组合在一起可以帮助我们对图像进行分类。为了直观地验证我们的分组技术有多好，我们需要首先投射到二维或三维空间。我将介绍一个例子，其中为了可视化的目的，手写数字的图像从 784 维投影到 2 维。

方法

t-随机近邻嵌入(t-SNE)技术是由 L.J.P. van der Maaten 和 G.E. Hinton 于 2008 年提出的一种非线性降维方法。人们通常使用 t-SNE 进行数据可视化，但你也可以将其用于许多其他机器学习任务，例如减少特征空间和聚类，等等。(你可以在这里了解更多关于 t-SNE 方法及其在几种编程语言中的实现。)

与最流行的降维技术主成分分析(PCA)相比，t-SNE 更擅长捕捉数据中的非线性关系。PCA 基于寻找最大化数据线性变化的新向量来降低特征空间的维度。因此，当数据的线性相关性很强时，PCA 可以在不丢失信息的情况下显著降低数据的维数。(你不需要总是在 PCA 或 t-SNE 之间选择，因为你可以将它们结合起来，并获得每种技术的好处。参见示例这里的，其中 PCA 用于减少特征空间，t-SNE 用于可视化 PCA 减少的空间。)

t-SNE 最重要的参数:

1. 困惑-根据经验猜测每个点的近邻数量。帮助平衡数据的本地和全局方面。
2. 学习率 —通过指定每次迭代改变多少权重，该值影响学习的速度。
3. 最大迭代次数 —执行迭代次数的上限。

数据

在这个例子中，我使用了 MNIST 手写数字数据库，你可以在这里下载。该数据库包含数千幅从 0 到 9 的数字图像，研究人员用这些图像来测试他们的聚类和分类算法。完整的数据集由 60，000 张用于训练的图像和 10，000 张用于测试的图像组成，但是为了简化这个示例，我从数据库中每位数抽取了大约 1，000 张图像，因此总共有 10，000 张图像。样本数据集的每一行都是原始图像的矢量化版本(大小为 28 x 28 = 784)以及每个图像的标签(零、一、二、三、…、九)。因此，数据集的维数是 10，000(图像)乘 785 (784 像素加一个标签)。

我在探索 SNE 霸王龙时学到了什么

在写这篇博客之前，我从来没有机会了解 SNE 霸王龙。每当我需要降低特征空间的维数时，我都会使用 PCA。我知道主成分分析对于降低列线性相关的数据集的维数非常有用。现在我知道，当你的列的关系是非线性的时候，t-SNE 是一个可行的选择。

这是几百次迭代后 t-SNE 分组的样子…

t-SNE on MNIST Data Set (at iterations 620)

github 回购上的分步说明。

在这里找到更多关于 Watson Studio 桌面的信息，或者在这里找到数据精炼的信息。

特别感谢史蒂夫·摩尔对这篇文章的巨大反馈。

Twitter:@ castan LinkedIn:@jorgecasta

使用 tiobeindexpy 可视化编程语言流行度

原文：https://towardsdatascience.com/visualize-programming-language-popularity-using-tiobeindexpy-f82c5a96400d?source=collection_archive---------7-----------------------

尽管我们中的大多数人会用一种主要的编程语言进行编码，但是关注编程世界中发生的变化总是有好处的。TIOBE 是一个已经为编程语言创建了一个索引的组织，并且每个月跟踪这个索引的变化。

在本帖中，我们将使用tiobeindexpy Python 包来可视化编程语言的流行程度，这样它就可以作为一个小追踪器，供我们每个月重温。

关于套餐:

tiobeindexpy是一个 Python 包(PyPi 上有)，给我们提供了官方网站的 TIOBE 索引摘录。

安装:

使用pip可以安装tiobeindexpy的稳定版本。

pip install tiobeindexpy

如果你有 Python3，请确保使用pip3 install tiobeindexpy以避免任何冲突。

目标

在练习结束时，我们要努力完成三件事。

• 最流行的 20 种编程语言是什么(截至 2019 年 2 月)
• 谁是前 5 名收益者(2018 年 2 月与 2019 年 2 月-当前前 20 名中的收益者)
• 谁是前 5 名输家(2018 年 2 月与 2019 年 2 月-当前前 20 名中的输家)

加载库

作为典型的体面的编码风格，让我们从加载所需的库开始。

from tiobeindexpy import tiobeindexpy as tbpy
import seaborn as sns

需要注意的是，一旦库被加载，tiobeindexpy从 TIOBE 索引网站下载所需的数据。因此，所有其他后续函数将只获取该数据，而不会进行实际的服务器调用。

地块大小和主题

我也更喜欢在开始时设置地块大小及其主题——如果有人想在不深入研究代码的情况下使用这些参数，这会更容易。

sns.set(style = "whitegrid")
sns.set(rc={'figure.figsize':(11.7,8.27)})

前 20 名

首先，我们将使用来自tiobeindexpy的函数top_20()来提取基于 TIOBE 指数评级的前 20 种编程语言。

top_20 = tbpy.top_20()

在我们开始可视化数据之前，让我们通过打印来验证数据是否真的可用。

top_20

从上面的输出可以看出，很明显 Python 对象top_20是一个熊猫数据帧，它实际上是 2019 年 3 月的数据帧。您可能还会注意到 Ratings and Change.1 列中数值旁边的%符号——这也意味着这些列在提取的数据帧中必须是字符串，因此需要进行前置处理。

数据预处理

在这一步，我们将strip(移除)上述两列中的%符号，并将它们类型转换为浮点字段。

top_20['Ratings'] = top_20.loc[:,'Ratings'].apply(lambda x: float(x.strip("%")))top_20['Change.1'] = top_20.loc[:,'Change.1'].apply(lambda x: float(x.strip("%")))

开始数据可视化

我们已经对数据进行了预处理，现在可以开始可视化编程语言排名了。

前 20 名编程语言

我们可以从一个非常简单的排名前 20 位语言的条形图开始(基于它们的 TIOBE 指数评级)

sns.barplot('Ratings', 'Programming Language', data = top_20).set_title('Mar 2019 - Programming Popularity')

Java、C、Python —是基于 TIOBE 指数的前 3 名语言。Java 和 Python 之间的评级差异似乎很大，这让我想了解一下 TIOBE Index 方法论的清晰性。

在 2018 年到 2019 年之间

世界上发生了很多变化，特别是在 2018 年和 2019 年之间的技术领域，所以让我们试着看看一年内的变化是什么样的:

涨幅前五名

sns.barplot('Programming Language', 'Change.1', 
            data = top_20.sort_values("Change.1",ascending = False)[0:5]).set_title('Mar 2018 vs 2019 - Language Popularity - Biggest Gainers from Top 20')

【VB.NET】和c++Python跃居首位。

前 5 名输家

sns.barplot('Change.1', 'Programming Language', 
            data = top_20.sort_values("Change.1",ascending = True)[0:5]).set_title('Mar 2018 vs 2019 - Language Popularity - Biggest Losers from Top 20')

C#、PHP、Ruby——在变化百分比(负值)方面一直是排行榜冠军。

到目前为止，这给了我们一个很好的月度图片，以及编程语言的流行程度是如何变化的。

名人堂——过去 15 年

让我们抽象一下，看看每年名人堂的获奖者是什么编程语言。

我们可以简单地使用tiobeindexpy的函数hall_of_fame()来提取名人堂数据。

hof = tbpy.hall_of_fame()

上面输出的一个稍微格式化的表。

hof.style.set_properties(**{'background-color': 'black',
                           'color': 'lawngreen',
                           'border-color': 'white'})

这些数据一次又一次地显示出，当一种新的趋势出现时，Python 如何选择，并且以这种方式，它如何成为名人堂中出现次数最多的条目之一。

摘要

在这篇文章中，我们看到了如何使用 python 包tiobeindexpy和seaborn来可视化基于 TIOBE 索引的编程语言流行度(排名)。

参考

• 这里使用的全部代码可以从 Github 上的 Jupyter 笔记本中获得
• TIOBE 指数办公室网站
• tiobeindexpy github 回购