您可以从命令行运行 Oracle JET app:

发球

JavaScript 代码，用于执行后端调用，并构建带有支持升级请求的 tweets 数组。

这段代码使用了许多 Oracle JET 库。我建议浏览一下 Oracle JET cookbook ，它为每个 UI 组件提供了一个交互式示例列表。

图表和列表组件由 Oracle JET 标记呈现:

我的目标是展示用于情感分析的机器学习模型如何适应企业应用架构，包括后端和客户端 UI 实现。我希望这个航空公司支持请求升级的实际用例有助于在您的组织中应用机器学习，并给出如何解决您自己的业务挑战的想法。

像特朗普一样用 One2Seq 模型发推特

原文：https://towardsdatascience.com/tweet-like-trump-with-a-one2seq-model-cb1461f9d54c?source=collection_archive---------0-----------------------

在本文中，我将向您介绍我的项目的大部分内容，我创建了一个一对一的模型，可以生成类似于 Trump 的推文。实际模型与我在我的“如何构建你的第一个聊天机器人”文章中构建的模型非常相似。这个模型的两个关键区别是输入和不包括注意力。注意力被排除在外，因为它没有显著提高生成的推文的质量。创建输入的步骤将是本文的重点。作为预览，我们将遵循以下路径:

• 清理特朗普的推文。
• 使用预先训练的单词向量创建单词向量( GloVe — Twitter 200d) )。
• 平均一条推文的词向量的维度。
• 使用主成分分析将维数减少到 1。
• 根据主成分分析值对推文进行排序。
• 通过文字的质量来限制推文。

我真正喜欢这个模型的地方是，我希望你也会喜欢，我们如何使用这样一个简单的输入，一个值，来生成一条推文。此外，从我们如何创建输入数据，我们将能够在某种程度上控制我们生成的推文的风格。

为了设定你的期望，这里有几个你可以用这个模型创建的推文的例子:

• 谢谢你亚利桑那！# makamericagreatagain # trump 2016
• 必须阻止希拉里
• 记得出来投票！#杂志#特朗普 2016

注意:我将从我的代码中删除注释，以帮助保持简短。如果你想看评论和我的完整代码，请访问这个项目的 GitHub 页面 。

我们开始吧！

这个项目的数据来自 Kaggle 上的数据集，它包含了 7375 条推文。我们需要做的第一件事是清理我们的推文。

def clean_tweet(tweet):
    tweet = tweet.lower()
    tweet = re.sub(r'https?:\/\/.*[\r\n]*', '', tweet, flags=re.MULTILINE)
    tweet = re.sub(r'[_"\-;%()|.,+&=*%]', '', tweet)
    tweet = re.sub(r'\.', ' . ', tweet)
    tweet = re.sub(r'\!', ' !', tweet)
    tweet = re.sub(r'\?', ' ?', tweet)
    tweet = re.sub(r'\,', ' ,', tweet)
    tweet = re.sub(r':', ' : ', tweet)
    tweet = re.sub(r'#', ' # ', tweet)
    tweet = re.sub(r'@', ' @ ', tweet)
    tweet = re.sub(r'd .c .', 'd.c.', tweet)
    tweet = re.sub(r'u .s .', 'd.c.', tweet)
    tweet = re.sub(r' amp ', ' and ', tweet)
    tweet = re.sub(r'pm', ' pm ', tweet)
    tweet = re.sub(r'news', ' news ', tweet)
    tweet = re.sub(r' . . . ', ' ', tweet)
    tweet = re.sub(r' .  .  . ', ' ', tweet)
    tweet = re.sub(r' ! ! ', ' ! ', tweet)
    tweet = re.sub(r'&amp', 'and', tweet)
    return tweet

这段代码将删除任何链接和无用的字符，并重新格式化文本，以便我们可以最大限度地利用 GloVe 的预训练单词向量。例如，所有的标签都与文本分开。这是因为 GloVe 没有针对 hashtagged 单词的预训练单词向量，所以如果我们想要利用这些预训练向量，我们需要进行这种分离。

注意:我们将使用 GloVe 的 Twitter 矢量。

以下是一些干净的推文示例:

• 今天，我们向所有曾在我们的军队中服役的人表达最深切的感谢
• rt @ ivankatrump:投票给我父亲竞选美国总统真是一个超现实的时刻！发出你的声音并投票！#选择 2
• 晚上 9 : 45 看投票结果#选举之夜#杂志

为了生成单词向量，我们首先需要从 GloVe 的单词向量中创建一个嵌入索引。

embeddings_index = {}
with open('/Users/Dave/Desktop/Programming/glove.twitter.27B/
           glove.twitter.27B.200d.txt', encoding='utf-8') as f:
    for line in f:
        values = line.split(' ')
        word = values[0]
        embedding = np.asarray(values[1:], dtype='float32')
        embeddings_index[word] = embedding

在这个文件中有 1，193，514 个单词嵌入，每个嵌入有 200 个维度。

我们将使用这个嵌入指数为每条推文创建一个“平均”嵌入。为此，我们将从“空”嵌入开始(所有 200 个值[对于 200 个维度]将为 0)。如果 tweet 中的一个单词在索引中，它的嵌入将被添加到“空”嵌入中。如果 tweet 中的一个单词不在索引中，那么“空”嵌入中将不会添加任何内容。在考虑了推文中的每个单词后，我们将根据推文中的单词数对每个维度进行平均。这些平均维度将为每条推文创建我们的“平均”嵌入。

以下是相关的代码:

embedding_dim = 200 embed_tweets = [] # Contains the 'average' embedding for each tweetfor tweet in clean_tweets:
    avg_embed = np.zeros(embedding_dim) 
    for word in tweet.split():
        embed = embeddings_index.get(word)
        if embed is not None:
            avg_embed += embed 
    embed_tweets.append(avg_embed/len(tweet.split()))

为了创建这些 *tweet 嵌入，*我们可以使用其他方法，比如 Word2Vec。Word2Vec 的好处是不会有任何空嵌入，但考虑到我们正在处理的数据量，只有 7375 条推文，我认为利用 GloVe 更大的数据集会更好。你很快就会看到，使用手套效果很好。

我们的下一步是将数据的维度从 200 减少到 1。我们将 reduction 设置为 1，以简化和组织我们的输入数据，并使其易于生成我们想要的 tweet 类型，例如。如果我们想要一条有更多标签或者只有文字的推文。

正如你可能已经预料到的，我们将使用 PCA(主成分分析)来降低数据的维度。

pca = PCA(n_components=1, random_state = 2)
pca_tweets = pca.fit_transform(embed_tweets)

现在，我们的每条推文都有一个 PCA 值，我们将从最小值到最大值对它们进行排序，这样类似的推文将更加接近。

pca_tweets_list = [] # Contains the pca values
for tweet in pca_tweets:
    pca_tweets_list.append(tweet[0])order = np.array(pca_tweets_list).argsort()
pca_labels = order.argsort()
pca_labels *= 2 

我们将我们的pca_labels乘以 2，以便更简单地生成新的推文。虽然我们不会使用所有的 tweet 来训练我们的模型，但是所有的训练 tweet 都是偶数。为了确保生成新的 tweet，你需要做的就是使用一个奇数作为输入。这个生成的 tweet 应该类似于训练数据中的 tweet，其值接近您的输入值。

为了了解 Trump 发布的推文的类型，我们将使用 KMeans 将推文分组。pca_tweets将是我们对 KMeans 的输入，在使用 3-10 个聚类检查该函数的结果后，我认为 4 个聚类最好地将 Trump 的推文分成不同的组。

kmeans = KMeans(n_clusters=4, max_iter = 1000, n_init = 20, random_state=2).fit(pca_tweets)
labels = kmeans.labels_

每组包含以下数量的推文:

1(红色):315，2(橙色):2600，3(黄色):1674，4(蓝色):2782

推文由它们的 KMeans 标签着色，但是输入到 TSNE 的数据是embed_tweets。这张图表明，你可以将推文分成一些合理的不同类别。它并不完美，如果你愿意，你可以为自己创造一些情节，但我认为这是最好的结果。

接下来，我们可以看看 PCA 标签与 tweet 组相比有多好。

I’d make this graph bigger, but Medium won’t let me

正如所料，鉴于 tweet 组是使用 PCA 数据创建的，我们可以看到四个明显的组。这也提供了一个很好的可视化来比较不同大小的推文组，并可以帮助您在想要生成推文时选择推文类型。

在我的 iPython 笔记本中，我会更详细地介绍每个组中的单词和推文，但为了给你一个示例，这里是每个组的一些推文:

Group # 1 - short tweets with hashtags
#1: # electionday 
#2: rt  @ donaldjtrumpjr :  thanks new hampshire ! !
    # nh  # newhampshire  # maga 
#3:  # draintheswamp !

Group # 2 - long tweets that are retweeted
#1: rt  @ ivankatrump :  such a surreal moment to vote for my father 
    for president of the united states ! make your voice heard and 
    vote !  # election2
#2: rt  @ erictrump :  join my family in this incredible movement to  
    # makeamericagreatagain ! now it is up to you ! please  # vote 
    for america ! https : 
#3: rt  @ donaldjtrumpjr :  final push ! eric and i doing dozens of 
    radio interviews we can win this thing ! get out and vote !  # 
    maga  # electionday ht

Group # 3 - typically involve a data/time/location
#1: watching the returns at 9 : 45 pm # electionnight  # maga 
#2: monday  11/7/2016 
    scranton pennsylvania at 5 : 30 pm 
    grand rapids michigan at 11 pm  
#3: rt  @ ivankatrump :  thank you new hampshire !  

Group # 4 - longer tweet, mostly just text
#1: today we express our deepest gratitude to all those who have  
    served in our armed forces  # thankavet 
#2: busy day planned in new york will soon be making some very 
    important decisions on the people who will be running our 
    government !
#3: love the fact that the small groups of protesters last night 
    have passion for our great country we will all come together and 
    be proud !

为了帮助模型生成最佳推文，我们将通过一些措施来限制我们的训练数据。我们要做的第一件事是建立一个词汇到整数(vocab_to_int)字典和 int_to_vocab 字典，其中只包括在特朗普的推文中出现 10 次或更多次的单词。为什么是 10？我对此没有任何“硬”的理由，但这将有助于我们生成的推文听起来更像特朗普的典型推文，而且这将有助于模型更好地理解每个单词的意思，因为它会看到至少 10 次。如果阈值只是 2 或 3，模型将很难理解和使用很少出现的单词。

threshold = 10vocab_to_int = {}value = 0
for word, count in word_counts.items():
    if count >= threshold:
        vocab_to_int[word] = value
        value += 1int_to_vocab = {}
for word, value in vocab_to_int.items():
    int_to_vocab[value] = word

接下来，我们将限制我们将使用的推文的长度。在训练数据中，我选择了 25 作为 tweet 的最大长度。选择该值是因为它是模型仍能很好学习的最大长度。再长一点，模型就很难学习推文，再短一点，我们就会进一步限制我们的训练数据。

我们还将设置一个限制。是一个标记，用于表示不包括在我们的训练词汇中的单词。如果一条推文中出现多个令牌，则该推文将不会用于训练模型。我尝试将限制增加到 2，但这导致在生成的 tweets 中出现太频繁。

max_tweet_length = 25
min_tweet_length = 1
unk_limit = 1short_tweets = []
short_labels = []for i in range(len(int_tweets)):
    unk_count = 0
    if len(int_tweets[i]) <= max_tweet_length and \
       len(int_tweets[i]) >= min_tweet_length:
        if len(int_tweets[i]) == 1:
            if int_tweets[i][0] != vocab_to_int['<UNK>']:
                short_tweets.append(int_tweets[i])
                short_labels.append(pca_labels[i])
        else:
            for word in int_tweets[i]:
                if word == vocab_to_int['<UNK>']:
                    unk_count += 1
            if unk_count <= unk_limit:
                short_tweets.append(int_tweets[i])
                short_labels.append(pca_labels[i])

作为为模型准备数据的最后一步，我们将按长度对推文进行排序。这样做将有助于我们的模型训练得更快，因为早期的批次将包含更短的推文。每批中的推文需要具有相同的长度，因此通过对推文进行排序，将避免长推文与短推文一起被批量处理。

sorted_tweets = []
sorted_labels = []for length in range(1,max_tweet_length+1):
    for i in range(len(short_tweets)):
        if length == len(short_tweets[i]):
            sorted_tweets.append(short_tweets[i])
            sorted_labels.append([short_labels[i]])

这就是创建我们的训练数据！这需要做一些工作，但是可以说你的输入数据是模型中最重要的部分。没有好的训练数据，模型将无法生成好的输出。

本文的最后一部分是如何生成推文。有两种不同的方法可以使用。

选项 1:找一条类似的推文

通过这种方法，你可以输入与最相似的推文匹配的单词或短语。

create_tweet = "I need your help to make america great again! #maga"create_tweet = clean_tweet(create_tweet)create_tweet_vect = vectorize_tweet(create_tweet)create_tweet_pca = pca.transform(create_tweet_vect)similar_tweet = min(pca_tweets_list, 
                    key=lambda x:abs(x-create_tweet_pca))for tweet in enumerate(pca_tweets_list):
    if tweet[1] == similar_tweet:
        print("Most similar tweet:", pca_labels[tweet[0]])
        break

• 在create_tweet中，输入您想要匹配的任何文本。
• 这条推文将被清理，然后使用与我们进行“平均”嵌入时输入数据相同的方法转换为向量。
• 推文的“平均”嵌入将被用于找到其 PCA 值。这个值将与最接近的 tweet 匹配。
• 匹配的 tweet 的 PCA 值将用于查找其 PCA 标签。这个标签是模型的输入。

如果你对这条最接近的推文的内容感到好奇，那么下面是给你的代码！

tweet_type = 3464closest_type = min(short_labels, key=lambda x:abs(x-tweet_type))
words = []
for tweet in enumerate(short_labels):
    if tweet[1] == closest_type:
        for num in short_tweets[tweet[0]]:
            words.append(int_to_vocab[num])
print(" ".join(words))

tweet_type可以认为是 PCA 标签。该值将与用于训练模型的最接近的标签相匹配。将打印出与最近标签相关的文本。

作为这种方法局限性的一个例子，我用了这样一句话“我需要你们的帮助，让美国再次伟大！#maga "作为我的create_tweet，返回的tweet_type和文字是:3464，“希拉里是有史以来竞选美国总统最腐败的人# draintheswamp”。

这些文本差别很大，但是它们的结构是相似的，多个普通的单词和一个标签。我同意这是第四组风格的推文的模式。

选项 2:输入一个值

这是更简单的选择，包含了更多的随机性。你需要做的就是选择一个tweet_type，我建议你参考推文组的范围来控制推文的风格。您还可以通过设置 sequence_length 的值来控制您想要生成的 tweet 的长度，但我将其设置为随机整数，因为我喜欢危险地生活。

tweet_type = 3464checkpoint = "./best_model.ckpt"loaded_graph = tf.Graph()
with tf.Session(graph=loaded_graph) as sess:
    loader = tf.train.import_meta_graph(checkpoint + '.meta')
    loader.restore(sess, checkpoint) input_data = loaded_graph.get_tensor_by_name('input:0')
    logits = loaded_graph.get_tensor_by_name('logits:0')
    sequence_length = 
        loaded_graph.get_tensor_by_name('sequence_length:0')
    keep_prob = loaded_graph.get_tensor_by_name('keep_prob:0')tweet_logits = sess.run(logits, 
                        {input_data: [[tweet_type]], 
                         sequence_length: np.random.randint(3,15),
                         keep_prob: 1.0})[0]# Remove the padding from the tweet
pad = vocab_to_int["<PAD>"]print('Tweet')
print('  Word Ids: {}'.format(
         [i for i in np.argmax(tweet_logits, 1) if i != pad]))
print('  Tweet: {}'.format(" ".join([int_to_vocab[i] for i in 
                          np.argmax(tweet_logits, 1) if i != pad])))

这个项目到此为止！我希望你喜欢了解它，如果你想看到整个过程，那么就去我的 GitHub 吧。如果您有任何问题、意见或建议，请在下面发表。

如果你对扩展这项工作感兴趣，我的一个想法是对生成的推文提供更大的控制。我认为如果我们可以在输入数据中包含一个关键字(或多个单词)会很好。这应该有助于我们控制我们想要生成的推文的风格和上下文。

感谢阅读！

你需要人类对人工智能的适当信任

原文：https://towardsdatascience.com/twiml-ai-meetup-trust-and-ai-86c32f91a0e0?source=collection_archive---------4-----------------------

TWiML & AI meetup talk:信任人工智能

我很高兴能在 TWiML 人工智能会议上发表关于人工智能信任的演讲。这个话题的核心是人类如何使用机器，以及他们如何将机器融入他们的团队。正如我们将看到的，这是一个非常重要但难以理解的话题。

“信任促进合作行为”

为了开始讨论，我们回顾了关于信任和自动化主题的四篇论文:

• 对心智模型的一些观察 (1987)
• 人类和自动化:使用、误用、废弃、滥用 (1997)
• 紧急疏散场景中机器人的过度信任 (2016)
• 自动化中的信任:整合影响信任因素的经验证据 (2015)

所有这些论文的关键在于，它们讨论了过多(误用)和过少(不用)之间的信任平衡。有许多因素可以增加信任度，但是我们应该总是构建具有最大信任度的系统吗？

在回顾了论文之后，我们开始深入研究在将人和机器结合起来时应该考虑的问题。这不是人在回路中(HITL)对人在回路外(OOTL)的人工智能。事物的本来面目也不一样。

说到 HITL，它不再仅仅是一个人和一台机器。它是与智能生态系统一起工作的人类组织。我们需要了解他们如何最好地合作。

如果你认为任何系统对人类来说都是真正的 OOTL，那么你就没有正确设定系统的边界。总有人类以某种方式参与其中。即使只是你的客户受到影响。你需要将他们纳入你的考虑范围。

在考虑信任时，责任是一个重要因素。当事情确实出错时，谁需要对此负责？

That is my exit!

如果上面的车是一辆自动驾驶汽车，从技术上讲它没有发生事故，但它确实需要对它的所作所为负责、而不是其他人类卡车司机。

如何为您的应用程序确定合适的信任度？这可以在不投入月复一月的数据清理和模型训练时间的情况下完成。你可以用非编码原型来做，就像我们在各种项目中做的那样。

最后，有太多的因素影响信任，你需要用真实的人来测试系统，了解他们需要什么。机器不会取代人类的目的。

资源

幻灯片:

[## TWiML & AI:信任与人工智能

信任与爱克里斯巴特勒@ philosophie.is @克里斯博特·https://goo.gl/m1PaVi

docs.google.com](https://docs.google.com/presentation/d/e/2PACX-1vTa6ebnvjGk1agTlztTFK4oJCM28UrkWbYuxzS_5Y5-atyYWxER4uA9N3l7X1dIVl_xb4mOqBox6pPx/pub?start=false&loop=false&delayms=3000)

其他参考:

• 谷歌的高绩效团队和信任
• TWiML & AI 播客#110 与 Ayanna Howard
• 急救机器人视频
• 为什么部队不信任无人机
• 机械战警(2014)
• 安慰剂按钮(假恒温器)
• 控制偏差的错觉
• 回路中的机器接近
• 人在回路中的机器学习:来自 StitchFix 的教训
• 星球大战社交网络
• 那是我们的出口！
• 道德崩溃区
• 计算机化社会中的问责制
• WoZ 方式:实现实时远程交互原型&在路上车辆中观察
• 康奈尔大学的温迪·朱
• 在用户研究中测试人工智能概念
• 机器的移情映射
• 混淆映射

关于克里斯·巴特勒

我帮助团队理解他们应该用以人工智能为中心的解决方案解决的真正的商业问题。我们工作的团队通常被要求用他们拥有的数据“做一些有趣的事情”。我们通过偶发事件相关性帮助他们避免局部极值，并专注于解决巨大的业务问题。我的背景包括在微软、KAYAK 和 Waze 等公司超过 18 年的产品和业务开发经验。在 Philosophie，我创造了像机器移情映射和困惑映射这样的技术，以在构建人工智能产品时创建跨团队对齐。如果你想了解更多或者通过邮箱、 LinkedIn 联系，或者访问http://philosophie.is/human-centered-ai。

Twitter 广告

原文：https://towardsdatascience.com/twitter-advertising-1d497d066fef?source=collection_archive---------4-----------------------

介绍

这是我在大会数据科学沉浸式项目中的顶点项目的非技术性报告。顶点计划是指参加该计划时所学一切的高潮。我选择对 Twitter 数据执行自然语言处理(NLP ),以便协助广告活动。这个项目更多地面向广告商、市场营销和任何想要扩展他们的客户关系平台以与他们的追随者交流的公司。

目标

通过推文的 NLP，公司可以衡量人们对他们产品的感受。我的目标之一是创建一个模型，对一条信息是否具有积极或消极的情感价值进行分类。这种分类的一部分是过滤掉那些正面/负面的推文，看看问题源自哪里。一个公司可以直接联系那些对他们的产品有问题的顾客，同时奖励那些忠诚于这个品牌的顾客。

数据

出于介绍的目的，所有的工作都是用 python 编写的，使用了几个库。这些库包括 Numpy、Pandas、Matplotlib、Scikit Learn 和 Keras。通过使用 Twitter API，tweets 被挖掘和收集。推文以压缩的 JSON 格式返回。如下例所示，信息是嵌套的，通常难以阅读。

通过一个自动化的过程，某些特征被选中，数据被保存到一个熊猫数据框架中。

本项目中使用了以下功能:

• 创建时间:创建推文的时间戳。
• 收藏次数:这条推文被“收藏”的总次数
• 标签:与 tweet 相关联的标签。
• 位置:用户声明的位置。
• 挖掘时间:tweet 被挖掘的时间戳。
• 转发次数:这条推文被“转发”的总次数。
• 屏幕名称:用户的屏幕名称。
• 来源:推文的来源(即:设备)。
• 文本:推文的文本。
• 字数:一条推文中的总字数。
• tweet Length:tweet 的字符长度。

返回的数据不干净。我说它不干净是因为为了让我处理数据，我需要一种特定的格式。有许多函数是为处理这个过程而编写的。我清理数据的过程如下:

• 使用位置变量提取 tweet 的坐标。如果没有，我将它设置为加州旧金山。为什么是 SF？因为 Twitter 总部位于旧金山。
• created_at 和 mined_at 变量被转换为 datetime 对象以执行与时间相关的函数。
• hashtags 变量在开头接收' # '，空格被删除。这是为了让所有的标签保持相同的格式。
• 源变量删除了 html 代码。
• 文本变量移除了超链接，移除了“@”提及，单词被标记化。示例:

# 纹身 sForShawn 我是 思维 点歌 耳机 ，然后那根线就是歌迷们歌唱生活的声波聚会@ Shawn Mendes

变成了:‘纹身 sforshawn’，‘思考’，‘耳机’，‘电线’，‘声音’，‘海浪’，‘粉丝’，‘唱歌’，‘生活’，‘派对’

下图显示了数据清理后数据帧的外观:

特征工程

除了从 twitter 中挖掘出来的特性，还有其他一些特性是为了更好地理解数据而创建的。VADER(用于情感推理的效价感知词典)库包括情感强度分析器，该分析器是确定给定推文的情感值的基础。这是一个基于规则的情绪分析工具，专门针对社交媒体中表达的情绪。给定一条消息，分析器返回可测量的值:

• 消极情绪
• neu:中性情绪
• 积极情绪
• 复合:复合(即综合得分)

Nodebox 英语语言学图书馆允许通过回归意象词典进行心理内容分析。RID 对文本中主要、次要和情感过程思想进行评分。这是一个有趣的包，因为它开辟了一种查看信息的新方式。

• 初级:涉及梦和幻想的自由形式联想思维
• 二级:逻辑性强，以现实为基础，注重解决问题
• 情绪:恐惧、悲伤、憎恨、喜爱等的表达。

探索数据

探索性数据分析(EDA)是一种分析数据集以总结其主要特征的方法。我选择从两个不同的角度来看这些数据。第一种是对收集到的所有公共信息进行更全面的概述。第二个通过更具体的观点，好像我是一个对我的信息感兴趣的公司。我们先来看一个大概的看法。

我选择查看每个特性，并查看数据的整体视图。time_created 变量显示，大多数推文是在下午发送的，然后是在午夜之后的几个小时。请注意，这些时间是以太平洋标准时间为基准的。标签聚集了挖掘过程中讨论的主要话题。

收集的推文主要集中在美国，因为情感库是在英语语言上训练的。这也是看外国字符时的编码问题。如果没有命名城市，加利福尼亚州旧金山是默认城市，因此在其他位置中很突出。许多用户在他们的个人资料中没有位置，在他们的推文中也没有。Twitter 的总部在旧金山市中心，所以推文是从那里发出的。

sources 变量显示 twitter 的移动使用占据了首位。前三名依次是 iPhone、Android 和 Twitter 网络客户端。web 客户端指的是通过 web 浏览器在桌面上使用 twitter，以及在移动设备上使用 web 浏览器。

在将推文分成各自的情绪值后，我决定看看字数分布。负面和正面推文的字数分布峰值都是每条推文 15 个字。中性的推文大多在 10 个字及以下。

对于 VADER 情绪分析，我将着眼于复合值。下图中的复合金额是 VADER 情绪分析的聚合值。复合值的范围从-1 到 1；消极情绪，到中性情绪，到积极情绪。大多数推文被评为中性。我认为这是因为 VADER 情绪分析器没有对 2017 年的新词进行训练，即:fleek。

#万豪

在对数据进行总体概述后，我想看看与万豪品牌相关的具体推文。获取数据的过程与之前相同，只是我将标签“#Marriott”传递给一个搜索参数，因此只返回与该标签相关的信息。

我想看的第一件事是#万豪在世界上的什么地方被谈论。使用坐标变量，我可以在地图上画出推文的来源。

通过观察一段时间内的情绪值，我能够衡量与万豪相关的正面或负面推文的数量。大多数推文都是对万豪的正面评价，只有少数是负面评价。

一条复合得分高达 0.951 的推文示例:

一条复合得分为-0.6551 的推文示例:

作为万豪的员工，我能够联系有问题的客户，并提供某种解决方案。同样的道理也适用于奖励评论最好的酒店。

数据建模

VADER 情感分析器是对推文情感价值进行分类的基础。我想看看我是否能利用课堂上学到的模型对推文进行分类。在继续之前，我需要将文本数据转换成 python 可以理解的格式。我用 word2vec 从单词中创建向量。在 word2vec 中，使用了单词的分布式表示。取一个有几百维(比如 300 维)的向量。每个单词都由这些元素的权重分布来表示。因此，向量中的元素和单词之间不是一对一的映射，而是单词的表示分布在向量中的所有元素上，向量中的每个元素都有助于许多单词的定义。单词“dog”的 300 维向量示例:

# creates a vector given a sentence/tweet
# takes a list of words, and array size of w2v vector
# tokens == a list of words (the tokenized tweet)
# size == the dimensional size of the vectorsize = 300def buildWordVector(tokens, size):
    vec = np.zeros(size).reshape((1, size))
    count = 0.
    for word in tokens:
        try:
            vec+= w2v[word].reshape((1,size))
            count += 1.
        except BaseException: # handling the case where the token is not
            try:
                continue

    if count != 0:
        # get centroid of sentence
        vec /= count
    return vec

一旦每个单词都被矢量化，下一步就是创建推文本身的矢量。tweet 中的每个单词向量相加在一起，除以 tweet 中的单词总数，这为 tweet 创建了一个向量，它是相加向量的质心。这是我遇到的强大的东西。通过创建这些向量，您可以执行矩阵数学运算并找到新的模式。可以对这些向量执行余弦相似性，这使你能够看到相似的推文/词以及最相反的推文/词。一旦用户的推文被矢量化，就可以用同样的步骤为用户创建向量。

作为参考，有三类被分类:消极，中立和积极。数据被分成 85/15 的比例，用于训练和测试数据。我的基本估计是多项式逻辑回归。我正在查看更具体的回忆分数，因为回忆是“结果有多完整”。高召回率意味着算法返回了大部分相关结果。如你所见，中性分类高于其他分类。

额外树分类器是尝试的第二个模型。“额外树”分类器，也称为“极度随机化树”分类器，是随机森林的变体。与随机森林不同，在每一步都使用整个样本，并随机选取决策边界，而不是最佳边界。还是那句话，中性分类高于其余。负面分类的表现很糟糕。

我最后一次分类的尝试是用神经网络来完成。Keras 是用 Python 编写的开源神经网络库。我对 Keras 的第一次尝试是创建一个又深又宽的神经网络。它有 5 个致密层，分别含有 500、800、1000、300 和 3 个神经元。以及设置为 0.1、0.5、0.2、0.2 和 0.2 的每个密集层之前的下降层。前四层的激活是“relu”，最后一层是“softmax”。

# in order for keras to accurately multi-classify, must convert from # 1 column to 3 columns
y_train = keras.utils.np_utils.to_categorical(y_train,       num_classes=3)
y_test = keras.utils.np_utils.to_categorical(y_test, num_classes=3)# MULTI-CLASSIFICATION
# Evaluating with a Keras NN# fix random seed for reproducibility
seed = 7
np.random.seed(seed)from keras.constraints import maxnorm# Keras neural network deep and wide.
model_keras = Sequential()
model_keras.add(Dropout(0.1, input_shape=(train_vecs_w2v.shape[1],)))
model_keras.add(Dense(500, activation=’relu’, kernel_constraint=maxnorm(1)))
model_keras.add(Dropout(0.5))
model_keras.add(Dense(800, activation=’relu’, kernel_constraint=maxnorm(1)))
model_keras.add(Dropout(0.2))
model_keras.add(Dense(1000, activation=’relu’, kernel_constraint=maxnorm(1)))
model_keras.add(Dropout(0.2))
model_keras.add(Dense(300, activation=’relu’, kernel_constraint=maxnorm(1)))
model_keras.add(Dropout(0.2))
model_keras.add(Dense(3, activation=’softmax’))epochs = 20model_keras.compile(loss=’categorical_crossentropy’,
 optimizer=’adam’,
 metrics=[‘accuracy’])history = model_keras.fit(train_vecs_w2v, y_train, epochs=epochs, validation_data=(test_vecs_w2v, y_test), batch_size=32, verbose=2)score = model_keras.evaluate(test_vecs_w2v, y_test, batch_size=128, verbose=0)print ‘Evaluated score on test data:’, score[1]# summarize history for accuracy
plt.figure(num=None, figsize=(8, 6), dpi=100, facecolor=’w’, edgecolor=’k’)
plt.plot(history.history[‘acc’])
plt.plot(history.history[‘val_acc’], c=’r’, ls=’dashed’)
plt.title(‘model accuracy’)
plt.ylabel(‘accuracy’)
plt.xlabel(‘epoch’)
plt.legend([‘train’, ‘test’], loc=’upper left’)
plt.hlines(y=score[1], xmin=0, xmax=epochs)
plt.show()# summarize history for loss
plt.figure(num=None, figsize=(8, 6), dpi=100, facecolor=’w’, edgecolor=’k’)
plt.plot(history.history[‘loss’])
plt.plot(history.history[‘val_loss’], c=’r’, ls=’dashed’)
plt.title(‘model loss’)
plt.ylabel(‘loss’)
plt.xlabel(‘epoch’)
plt.legend([‘train’, ‘test’], loc=’upper left’)
plt.show()

所有的分类模型似乎都有一个模式。负面分类总是比其余的低。再看数据，负面情绪值的推文大概占整个数据集的 20%。中性的占 44%，积极的占 33%。下一步是将所有推文限制在相同的数据量。我决定从每个班级随机抽取 4000 个数据点。该数据然后被放入 70/30 的训练测试分割中；70%的数据用于训练，30%用于测试。我的下一步是尝试短而浅的神经网络设置。三个致密层，分别为 32、16 和 3 个神经元。每个密集层之前的三个下降层设置为 0.1、0.3 和 0.2。纪元已更改为 50，批次大小已更改为 2048。

# df is the pandas dataframe object which contains all the clean data# Function to create targets based on compound score
def get_targets(row):
    if row < 0:
        return 0
    elif row == 0:
        return 1
    else:
        return 2# Creating the targets based of the compound value
df['target'] = df['compound'].map(lambda x: get_targets(x))
neg = df[df.target == 0]
neu = df[df.target == 1]
pos = df[df.target == 2]# Randomly sampling tweets to a limit of 4000 each
neg_sampled = neg.sample(4000)
neu_sampled = neu.sample(4000)
pos_sampled = pos.sample(4000)# concating all sampled datasets together
df_test = pd.concat([neg_sampled, neu_sampled, pos_sampled])
df_test.shape# Creating training/testing data, 70/30 split
X_train, X_test, y_train, y_test = train_test_split(df_test.token_text, df_test.target, train_size=0.7)# For every tweet, creating a word vector array for tweet
X_train = np.concatenate([buildWordVector(z, num_features) for z in X_train])
X_train = scale(X_train)X_test = np.concatenate([buildWordVector(z, num_features) for z in X_test])
X_test = scale(X_test)# in order for keras to accurately multi-classify, must convert from 1 column to 3 columns
y_train = keras.utils.np_utils.to_categorical(y_train, num_classes=3)
y_test = keras.utils.np_utils.to_categorical(y_test, num_classes=3)# MULTI-CLASSIFICATION
# Evaluating with a Keras NN# fix random seed for reproducibility
seed = 7
np.random.seed(seed)leng = X_train.shape[1]
X_train = X_train.reshape(X_train.shape[0], 1, leng)
X_test = X_test.reshape(X_test.shape[0], 1, leng)# Keras neural network short and shallow
model_keras = Sequential()
model_keras.add(Dropout(0.1, input_shape=(X_train.shape[1],)))
model_keras.add(Dense(32, activation=’relu’, kernel_constraint=maxnorm(1)))
model_keras.add(Dropout(0.3))
model_keras.add(Dense(16, activation=’relu’, kernel_constraint=maxnorm(1)))
model_keras.add(Dropout(0.2))
model_keras.add(Dense(3, activation=’softmax’))# SGD Parameters
learning_rate = 0.01
decay_rate = learning_rate / epochs
momentum = .95
sgd = SGD(lr=learning_rate, momentum=momentum, decay=decay_rate, nesterov=True)model_keras.compile(loss=’categorical_crossentropy’,
 optimizer=’adam’,
 metrics=[‘accuracy’])# Model parameters
epochs = 50
batch = 2048history = model_keras.fit(X_train, y_train, 
 validation_data=(X_test, y_test), 
 epochs=epochs, 
 batch_size=batch, 
 verbose=0)score = model_keras.evaluate(X_test, y_test, 
 batch_size=batch, verbose=0)print ‘Evaluated score on test data:’, score[1]# summarize history for accuracy
plt.figure(num=None, figsize=(8, 6), dpi=100, facecolor=’w’, edgecolor=’k’)
plt.plot(history.history[‘acc’])
plt.plot(history.history[‘val_acc’], c=’r’, ls=’dashed’)
plt.title(‘model accuracy’)
plt.ylabel(‘accuracy’)
plt.xlabel(‘epoch’)
plt.legend([‘train’, ‘test’], loc=’upper left’)
plt.hlines(y=score[1], xmin=0, xmax=epochs)
plt.show()# summarize history for loss
plt.figure(num=None, figsize=(8, 6), dpi=100, facecolor=’w’, edgecolor=’k’)
plt.plot(history.history[‘loss’])
plt.plot(history.history[‘val_loss’], c=’r’, ls=’dashed’)
plt.title(‘model loss’)
plt.ylabel(‘loss’)
plt.xlabel(‘epoch’)
plt.legend([‘train’, ‘test’], loc=’upper left’)
plt.show()

使用 Keras 分类器的试验比以前的模型表现得更好。从回忆分数来看，负数看起来没有以前那么糟糕了。即使每个情感值都有 4000 个数据点，也可能是中性类有更多独特的词。进一步的测试将尝试添加一个 LSTM 层，以便添加一个记忆层，以及一个卷积层，以便找到隐藏的模式。

结论

获得更好的分类器分数所需的数据必须是特定的。它不可能是随机的推文。从字面上看，最负面的词和最正面的词都要被搜索和收集。这样做之后，我相信这个分类器会像 VADER 情感分析一样出色。

汽车品牌的推特情感分析

原文：https://towardsdatascience.com/twitter-sentiment-analysis-on-car-brands-c13d449eb9fc?source=collection_archive---------2-----------------------

Twitter 数据是一个丰富的来源，可以用来获取任何可以想象的话题的信息。这些数据可用于不同的用例，例如寻找与特定关键字相关的趋势、测量品牌情感以及收集关于新产品和服务的反馈。

在这篇文章中，我将从 twitter 中提取各种汽车品牌的数据。然后，我们将应用情感分析来了解在最近一段时间内，人们对不同汽车品牌的正面/负面看法。情感分析是确定一条内容是正面的、负面的还是中性的过程。这也被称为意见挖掘，得出一个发言者的意见或态度。这项技术的一个常见用例是发现人们对某个特定话题的感受。在我们的例子中，我们使用最近推文中的文字来发现人们对不同汽车品牌的感受。

我发现这篇文章和这段视频有助于弄清楚如何从 twitter api 中提取、过滤和处理数据。

#Import the necessary methods from tweepy library
from tweepy import Stream
from tweepy import OAuthHandler
from tweepy.streaming import StreamListener
import time#Variables that contain the user credentials to access Twitter API
#(Note: replace with your own values from [https://apps.twitter.com/](https://apps.twitter.com/))
consumer_key="consumer key"
consumer_secret="consumer secret"
author_token="author token"
author_secret="author secret"class listener(StreamListener):#This is a basic listener that just prints received tweets
def on_data(self, data):
   try:
     #writing data to file
     saveFile = open('tweetDBcars.csv','a')
     saveFile.write(data)
     saveFile.close()
     return(True)
   except BaseException, e:
     print 'failed ondata,',str(e)
     time.sleep(5)def on_error(self, status):
        print statusauth = OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(author_token, author_secret)twitterStream = Stream(auth, listener())# getting tweets that have any of these words
twitterStream.filter(track=['car' 
 'chevy','ford','toyota',
    'acura','kia','audi',
    'chrystler','dodge','ferrari'
    'fiat','buick','cadillac','chevrolet',
    'bmw','honda','jeep','lexus','mazda',
    'mini','nissan','tesla''volvo','saab','porshe'])

我让这个脚本运行了 6 天，累积了大约 115，000 条推文。Twitter api 在类似于 python 字典的 json 数据结构中为我们提供了关于每条 tweet 的大量数据。我们对 tweet 本身的内容感兴趣，可以通过键[“text”]访问它。

在处理大型数据集时，在 try/except 子句中捕获 tweet = json.loads(line)语句非常重要。尽管从 Twitter api 返回的数据通常是干净的，但可能会有错误，如果遇到一行坏数据，您希望避免破坏脚本。try/except 子句允许脚本跳过一行坏数据，继续处理剩余的 tweets。

tweets_data_path = 'twitDBcars.csv'tweets_data = []
tweets_file = open(tweets_data_path, "r")
for line in tweets_file:
    try:
        tweet = json.loads(line)
        tweets_data.append(tweet)
    except:
        continue

现在我们用微博创建一个熊猫数据框架

tweets = pd.DataFrame()index = 0
for num, line in enumerate(tweets_data):
  try:
     print num,line['text']
     tweets.loc[index,'text'] = line['text']
     index = index + 1 
 except:
     print num, "line not parsed"
     continue

为了提取关于特定品牌的推文，我们将每条推文中的单词与我们感兴趣的每个品牌的名称进行比较。如果我们找到了我们正在寻找的品牌，我们会在数据框中的新列“品牌名称”中对其进行跟踪。

def brand_in_tweet(brand, tweet):
    brand = brand.lower()
    tweet = tweet.lower()
    match = re.search(brand, tweet)
    if match:
        print 'Match Found'
        return brand
    else:
        print 'Match not found'
        return 'none'

下一步是评估每条推文的情绪。有几种方法可以进行情感分析。

从业者最常描述的有两种方法:

• 一种方法是收集一堆推文，让人们给它们贴上积极或消极的标签。然后使用已标记的数据集来训练算法，如朴素贝叶斯或随机森林。然后，训练好的模型可以用于新的数据，以估计情绪。
• 第二种方法是使用词典，我们将推文中的单词与词典中的单词(或 n-grams)进行比较，以对每个单词的积极/消极情绪进行评分。然后，我们将每条推文的单词分数相加，得出推文的情感分数。

在本帖中，我们将通过使用 TextBlob 包来使用第二种方法。我们使用 TextBlob 的极性方法来查找每条推文的情感得分，并将其记录在 dataframe 中的新列“sentscore”中。(关于 TextBlob 如何计算情感得分的更多详细信息，请点击查看。)

from textblob import TextBlobfor index, row in tweets.iterrows():
    temp = TextBlob(row['text'])
    tweets.loc[index,'sentscore'] = temp.sentiment.polarity

我喜欢使用 ggplot 进行数据可视化，因为它强大而灵活，所以我将把数据帧写入一个 csv 文件，该文件可以导入到 r。

 for column in tweets.columns:
    for idx in tweets[column].index:
        x = tweets.get_value(idx,column)
        try:
            x = unicode(x.encode('utf-8','ignore'),errors ='ignore')          
            if type(x) == unicode:
                unicode(str(x),errors='ignore')
            else: 
                df.set_value(idx,column,x)
        except Exception:
            print 'encoding error: {0} {1}'.format(idx,column)
            tweets.set_value(idx,column,'')
            continue
tweets.to_csv('tweets_export.csv')

让我们读取 R 中的数据，并直观地检查这些数据

df_tweets = read.csv("tweets_export.csv")#let us look at the mean of sentiment scores for all brands
data_brand = df_tweets %>%
   group_by(brand) %>%
   summarise(mean_sentiment_score = mean(sentscore))ggplot(data=data_brand, aes(x=brand, y=mean_sentiment_score))+
  geom_bar(stat = "identity", aes(fill = brand))

我们注意到雷克萨斯的正面喜好度最高，丰田的负面喜好度最高。假设我们代理的客户是一家汽车经销商，他们想决定增加对哪些品牌的投资，这种从经销商身边的人那里收集的信息可能非常有用。

现在让我们更仔细地研究 3 个品牌:

#We subset the data for the brands ford, mini and kia to drill down into the variance of their sentiment over timedata_week <- df_tweets[df_tweets$brand %in% c("ford","mini","kia"),]ggplot(aes(x = day, y = sentscore), data = data_week) + 
  geom_smooth(aes(colour = brand))

随着时间的推移，起亚的正面喜好度有所上升，而福特的正面喜好度有所下降。假设我们是一家咨询公司，福特是我们的客户之一，我们需要进一步挖掘细节，以了解为什么积极情绪正在减少。

这是非常初步的分析。为了实现情感分析的高准确度，需要考虑几个因素，例如语言、领域、人口、年龄、俚语、词汇分析等。脸书和 AOL 面临的一些挑战和采取的方法分别在这里和这里讨论。我希望在不久的将来进一步研究这一分析。

同一主题的其他重要资源:

1. 用 twitter 分析大数据 —来自伯克利分校的视频和幻灯片——由来自 twitter 的员工演示的讲座。
2. 分析推文中表情符号的情感
3. 如何构建 twitter 情感分析器
4. 用 python 挖掘 twitter 数据(图书)
5. twitter 用户对薄荷烟的看法:内容和情感分析(研究论文)

我的其他项目很少在这里

Python NumPy 的两个很酷的特性:通过切片和广播进行变异

原文：https://towardsdatascience.com/two-cool-features-of-python-numpy-mutating-by-slicing-and-broadcasting-3b0b86e8b4c7?source=collection_archive---------1-----------------------

NumPy 是纯金。它快速、易学、功能丰富，因此是 Python 世界中几乎所有流行科学包的核心(包括 SciPy 和 Pandas ，这两个包在数据科学和统计建模领域应用最广泛)。在本文中，让我们简要讨论 NumPy 的两个有趣的特性，即。切片突变和播。

切片突变

事实证明，如果使用 NumPy 的简单切片/索引来创建子数组，子数组实际上指向主数组。简单地说，内存中的图表看起来像，

因此，如果切片数组被更改，它也会影响父数组。这可能是一个有用的特性，可以将所需的链传播到食物链的上游，但有时也可能是一个麻烦，因为您需要保持主数据集不变，并且只对子集进行更改。在这些情况下，您必须显式调用 np.array 方法来定义切片数组，而不仅仅是通过索引来切片。下面的代码说明了这一点，

说明性代码

mat = np.array([[11,12,13],[21,22,23],[31,32,33]])
print("Original matrix")
print(mat)
**mat_slice = mat[:2,:2] # *Simple indexing***
print ("\nSliced matrix")
print(mat_slice)
print ("\nChange the sliced matrix")
mat_slice[0,0] = 1000
print (mat_slice)
print("\nBut the original matrix? WHOA! It got changed too!")
print(mat)

结果看起来像是，

Original matrix
[[11 12 13]
 [21 22 23]
 [31 32 33]]

Sliced matrix
[[11 12]
 [21 22]]

Change the sliced matrix
[[**1000**   12]
 [  21   22]]

But the original matrix? WHOA! **It got changed** too!
[[**1000**   12   13]
 [  21   22   23]
 [  31   32   33]]

为了阻止这种事情发生，这是你应该做的，

# Little different way to create a copy of the sliced matrix
print ("\nDoing it again little differently now...\n")
mat = np.array([[11,12,13],[21,22,23],[31,32,33]])
print("Original matrix")
print(mat)
**mat_slice = np.array(mat[:2,:2]) *# Notice the np.array method***
print ("\nSliced matrix")
print(mat_slice)
print ("\nChange the sliced matrix")
mat_slice[0,0] = 1000
print (mat_slice)
print("\nBut the original matrix? NO CHANGE this time:)")
print(mat)

现在，子矩阵中的任何变化都不会改变原始矩阵，

Original matrix
[[11 12 13]
 [21 22 23]
 [31 32 33]]

Sliced matrix
[[11 12]
 [21 22]]

Change the sliced matrix
[[**1000**   12]
 [  21   22]]

But the original matrix? **NO CHANGE** this time:)
[[**11** 12 13]
 [21 22 23]
 [31 32 33]]

广播

NumPy 操作通常是在逐个元素的基础上对数组对进行的。在一般情况下，两个数组必须具有完全相同的形状(或者对于矩阵乘法，内部维度必须一致)。

当数组的形状满足某些约束 时，NumPy 的 广播规则放松了这个约束。当操作两个数组时，NumPy 按元素比较它们的形状。它从尾部维度开始，向前推进。在以下情况下，二维是兼容的

• 它们相等，或者
• 其中一个是 1

如果不满足这些条件，就会抛出一个value error:frames not aligned异常，表明数组具有不兼容的形状。结果数组的大小是沿着输入数组的每个维度的最大大小。

更多详情请查阅:https://docs . scipy . org/doc/numpy-1 . 10 . 1/user/basics . broadcasting . html。

下面的代码块按部就班地说明了这个想法，

用零初始化“开始”矩阵

start = np.zeros((4,3))
print(start)[[ 0\.  0\.  0.]
 [ 0\.  0\.  0.]
 [ 0\.  0\.  0.]
 [ 0\.  0\.  0.]]

创建一个行矩阵(向量)，

# create a rank 1 ndarray with 3 values
add_rows = np.array([1, 0, 2])
print(add_rows)[1 0 2]

将零矩阵(4x3)与(1x3)向量相加。自动地，1×3 向量被复制 4 次以使匹配零矩阵的行尺寸，并且这些值被添加到 4×3 矩阵中。

y = start + add_rows  # add to each row of 'start'
print(y)[[ 1\.  0\.  2.]
 [ 1\.  0\.  2.]
 [ 1\.  0\.  2.]
 [ 1\.  0\.  2.]]

创建列矩阵(向量)，

# create an ndarray which is 4 x 1 to broadcast across columns
add_cols = np.array([[0,1,2,3]])
add_cols = add_cols.T
print(add_cols)[[0]
 [1]
 [2]
 [3]]

将零矩阵(4x3)与(4x1)向量相加。自动地，4x1 向量被复制 3 次以使匹配零矩阵的列维度，并且这些值被添加到 4x3 矩阵中。

# add to each column of 'start' using broadcasting
y = start + add_cols 
print(y)[[ 0\.  0\.  0.]
 [ 1\.  1\.  1.]
 [ 2\.  2\.  2.]
 [ 3\.  3\.  3.]]

最后，标量被视为 1x1 矩阵，并精确复制到加法矩阵的大小以执行运算。

# this will just broadcast in both dimensions
add_scalar = np.array([100])  
print(start+add_scalar)[[ 100\.  100\.  100.]
 [ 100\.  100\.  100.]
 [ 100\.  100\.  100.]
 [ 100\.  100\.  100.]]

当您使用 NumPy 数组为像梯度下降这样的算法编写矢量化代码时，广播的效用得到了最好的实现。吴恩达 花了一个全视频讲座 **在他新的深度学习课程中用 Python 解释广播的概念。**它使得深度神经网络的前向和反向传播算法的实现相对无痛。

你也可以看看这个关于广播功能演示的视频…

Numpy Broadcasting explanation video

如有问题或想法分享，请联系作者tirthajyoti【AT】Gmail . com。你也可以查看作者的 GitHub 知识库 中其他有趣的 Python、R 或 MATLAB 代码片段和机器学习资源。也可以在 LinkedIn 上关注我。

佛罗里达大学学生政府选举二十年:使用机器学习获得更深刻的见解

原文：https://towardsdatascience.com/two-decades-of-uf-student-government-elections-using-machine-learning-for-deeper-insights-c137c0586466?source=collection_archive---------7-----------------------

三年前，我上了一堂统计学课，这门课涉及回归技术，除了统计学，我什么都不想。像班上的大多数人一样，我发现统计学很无聊、乏味，在我的日常生活中毫无用处。

怀着一丝希望，我问我的教授，我是否可以在我们刚刚被分配的回归项目中调用 audible，并尝试预测学生会选举的结果。从那以后，随着我在数据科学职业生涯中的进步，我从越来越学术和技术的角度零星地参与了这个项目。

这篇文章的其余部分将包含我的发现，我的失败，它们背后的数据，以及如何自己尝试这种类型的工作的说明。希望在我今年 12 月毕业后，其他学生可以利用这些数据，创建更好的模型和更有趣的见解。

数据

对于任何参与过地方选举的人来说，这并不奇怪，但是选举结果却保存在不同格式的几乎无法阅读的 pdf 文件中。通过 pdf 到文本转换器和手抄结果的结合，创造了整个 21 世纪 SG 选举的历史。

关于数据需要注意一些事情(在我的 github 上找到)。“Est”代表建立，我也称之为系统。该系统已经在学术上得到广泛研究，最突出的工作来自大卫·布拉德肖，他在 2013 年写了一篇关于它的论文。他(恰当地)将这一体系定义为“一个令人惊讶的复杂的赞助和讨价还价体系”，即“佛罗里达大学希腊社区的绝大多数和校园内几个最著名的非希腊学生组织的联盟，其中许多组织代表特定的少数群体，通常被称为“社区”。这些社区主要由亚裔美国学生联合会(AASU)、西班牙裔学生联合会(HSA)和黑人学生联合会(BSU)组成。学生政府的职位在希腊各学院之间进行交易，并给予社区的杰出成员，以创造多样性和包容性的外观。该系统在整个 20 世纪 70 年代和 80 年代在佛罗里达大学掌权，以确保除了上层阶级的白人男性，尤其是当时正在整合佛罗里达大学的有色人种，任何人都不能获得校园中重要和有声望的职位。你可以在这里或阅读更多关于系统的信息，甚至可以在这里观看一个关于它的视频，但这个项目的主旨是通过一个统计镜头来探索 SG。

通过探索性数据分析的独立机会

探索性数据分析(或 EDA)在技术上是“分析数据的过程，解释这些过程的结果的技术，以及规划数据收集以使其分析更容易的方法”，这只是“对数据提出问题”的一种更长的说法

数据库完成后，我的第一个问题是“这个系统在 21 世纪的主导地位如何？”系统党赢得了每一次总统选举，除了两次，一次是在 2004 年与贾迈勒·索维尔，另一次是在 2015 年与约瑟林·帕德隆-拉辛斯，但更细致的分析可能吗？我看了一下参议院，并绘制了自 2000 年以来春季选举的胜率，发现独立政党平均只赢得了他们竞选的 21.5%的选票，而系统政党赢得了令人震惊的 81.5%的选票(T3)。这是因为有些年份有多个独立政党，而有些年份则有无竞争的选举。

这张图显示了不同时间的差异。

Winning percentage over the years

事实证明，除了几场选举，这个系统已经成功赢得了绝大多数的选举。有鉴于此，独立政党什么时候表现得好？下面是一张成功聚会的图表，按机构、聚会时间(聚会在校园里有多长时间)分类。

Winning percentage by age of party

独立党派在 T4 的第一个学期和第二个学期表现最好，随着年龄的增长，他们的表现越来越差。随着时间的推移，建制派似乎也变得越来越差，但下降速度要慢得多。

很明显，当权派会赢(在很大程度上是因为贿赂有职位的学生和酒精，以及扣留 食物直到他们投票)。那么独立党派如何才能获胜呢？显然，一个答案是在校园的第一个学期集中精力进行选举，那时的投票率平均要高得多。但另一个潜在的努力是针对个别参议院席位。

SG 选举分为秋季和春季选举，秋季参议员按地理区域(宿舍或邮政编码)选举，春季参议员按学院(工程、商业)或年级(大一、大二)选举。就像在全国选举中一样，有些席位选举系统候选人的比率远远高于已经相当高的平均比率，即使经过一段时间。例如，在 A 区(校园东面的区域，包括所有的女生联谊会和附近的公寓楼)，几乎从来没有一个席位是由非体制或独立党派赢得的。根据年份的不同，A 区控制着参议院的大约 5% 到 10% 的席位。

也有倾向独立投票的席位。下面是独立党派的席位胜率图，给出了一个(伪)权力排名。在收集数据时，无穷大的样本大小是 1，平均值肯定是失真的。除此之外，独立党派赢得 50%以上的席位只有两个，家庭住房和毕业。

选举建模

在选举建模领域，学者和媒体机构经常使用所谓的基本面来预测选举结果。大卫·拜勒目前正在为 2018 年 11 月的参议院模型工作，他比我更好地定义了基本面，他说

“基本面基本上涵盖了直接投票之外的一切——总统的批准，……该州过去的选举结果，候选人的信息。”

这基本上是我们所拥有的数据。当处理这样的问题时，我想到了两种主要的方法。

支持向量机

首先，我想创建一个算法，如果数据被投射到二维空间，将能够创建一个超平面(在二维空间，这看起来像一条线。在我们的例子中，它作为一个多维平面存在，具有与数据相同的维数，将每次选举(给定年份、政党年龄、以前的选举结果、候选人数量等)分为两类，即获胜和失败。在数据科学中，我们称之为线性分类器。这项工作有很多潜在的算法，从 K-Nearest Neighbors 到 Perceptron，K-Nearest Neighbors 可以在训练集中找到 K 个最近的点，并允许每个点对预测进行投票，Perceptron 可以根据获得的每个新数据更新算法的权重。我最终选择了 SVM(支持向量机)分类器，因为我从理论上认为，有大量的选举很容易预测，而有少量的选举要困难得多。这让我想到了 SVM 分类器，因为 SVM 在线性分类器中最大化了相近案例之间的间隔。如果最后一段对你来说没有意义，那 100%没关系，因为一些聪明的人制作了一个图表，使这更容易理解。

有相当多的线可以将这两个类别分开，但是 SVM 找到了最大化这两个类别之间差距的线，这正是我们想要的。

在对数据进行大规模清理之后，我使用了 caret 包(用于预测建模/机器学习/统计分析，无论你喜欢怎么称呼它)来实现 SVM 算法。结果呢？回溯测试的准确率约为 80%。附上混淆矩阵(顶行是预测，第一列是实际结果。因此，这可以理解为“对于 SVM 预测参议员将会失败的选举，它得到了 130 个正确和 34 个不正确”)。

这个在 2018 年春季选举前创建的算法预测，Inspire(独立党)将赢得研究生参议院席位，并将输掉所有其他竞争性选举。在这种情况下，它预测了一个行政门票清扫和一个 38/50 参议院系统崩溃。事实证明这几乎是真的，Inspire 赢得了研究生院、牙科和美术院的席位，失去了所有其他竞争席位。参议院的总结果是 36/50 加上行政人员的票数，大约是 96% 准确。还不错！然而，我们得到的精确度超出了 95%的置信区间(精确度在 76%和 84%之间)，这可能是 2018 年选举中有第三个政党(尽管相当无组织和草率)而不是通常的两个政党的作用。有一点也是肯定的，政党数量的增加对独立政党赢得的参议院席位数量有显著的影响，对 2018 年春季的选举有影响。

随机森林

我想尝试的第二种方法是使用决策树(到目前为止，我最喜欢的决策树可以在这里找到)。同样，决策树有几十种不同的实现和评分机制，包括经典的分类和算法树，以及像 Boosted 树和 Random Forest 这样的集合树(可以在这里找到一篇很好的背景实现文章)。从图形上看，决策树是这样的。

What should I do with my night? A analysis with decision trees

这是一个相当简单，但非常有用的方法。一个更健壮的模型被称为随机森林，它将大量决策树与随机选择的变量相结合，并使用一组(可能相当糟糕)预测算法来创建一个新模型(这被称为集成学习)。我认为这个模型会表现得更好，因为决策树通常是我对选举的看法。候选人在商学院竞选吗？他们在系统中运行吗？那么他们很可能会赢。

实施后，我们得到了这个混淆矩阵，它转化为 89%的准确率，远远高于 SVM 方法。

随机森林算法的另一个好处是，由于它选择不同变量的方式，我们可以推导出每个变量的重要性(注意:X 轴上的 MeanDecreaseGini 是衡量类别杂质的一种方式。基尼系数的平均降幅越高，意味着该变量越重要)。

不出所料，影响最大的两个变量是席位和候选人是否是体制的一部分。考虑到这一点，仍然有人说这个系统不存在，因为它似乎能很好地预测选举结果，这确实显得很愚蠢。

在 2018 年春季选举中使用随机森林方法，随机森林在 SVM 分类器上的表现完全相同(96%)，但在测试数据上的准确率更高，为 89%。尽管如此，我还是决定在推特上发布一个略有改动的预测，说我认为 Inspire 将与工程学和 CLAS 一起赢得毕业生奖。不出所料，人类的表现远不如算法，工程和 CLAS 都受到了影响。吸取教训。

结论:事实证明机器学习是可行的

在整个项目中，我一直着迷于了解联合阵线选举的可预测性，即使是通过前美国参议员兼佛罗里达州州长鲍勃·格雷厄姆描述的选举

"在州和联邦政治中，我从未遇到过像佛罗里达大学那样咄咄逼人的活动."

我最初的目标是预测选举结果，在理解了数据并尝试了几次之后，我对结果非常满意。同样，数据和脚本都是公开的，我随时可以回答关于数据科学、用友 SG、它们的交集或者具体这个项目的问题。通过电子邮件联系我，或者在推特上找到我。

最后一点，我试图用所有领域的专业知识创建这些模型，但没有对系统如何积极地使佛罗里达大学成为一个更糟糕的地方发表意见，并且没有任何好的理由让任何人参与到 20 世纪 70 年代的活遗迹中。但我确信我的偏见会渗透进来。

我想公开感谢 William Ferra，他在该项目的数据收集和清理部分发挥了不可估量的作用。如果没有他，这个项目是不可能的，或者至少要花更长的时间。

两个比一个好:集合模型

原文：https://towardsdatascience.com/two-is-better-than-one-ensembling-models-611ee4fa9bd8?source=collection_archive---------4-----------------------

组装起初听起来像是一个非常吓人的词，但实际上看起来很简单…让我用一个类比来解释集合

Ensembling algorithms to obtain the cake of accuracy

集成有点像整个周末都在看网飞(通用 ML 算法)，这很好，但结合一些披萨或一个特殊的朋友，你就可以放松了，我说的“放松”是指达到 90%的准确率

因此，基本上集成/组合两个或更多的算法可以改善或提高你的性能。但是在组合的背后有一个逻辑…你不能只是随机地组合两个模型，并要求提高精确度…每件事背后都有一个数学…..因此，让我们深入探讨几种您可以尝试的组装方法…(如果你喜欢那种东西)

简单平均/加权法:

名字说明了一切…这种组合方法只取两个模型的平均值。但是这是怎么做到的…是山达基吗？

假设你已经使用了名为的算法将和结果是

*Actual_targets: 1 0 1 1 0 1**Predicted vals: 1 0 1 0 1 0*

现在你使用另一种叫做格雷斯的算法，结果是

*Actual_targets: 1 0 1 1 0 1**Predicted vals: 0 1 0 1 0 1*

威尔正确预测了前三个目标，而格雷斯正确预测了后三个目标

如果我们结合这两种算法(WILL & GRACE ),我们会得到一个相当不错的情景喜剧，我们的准确性肯定会增加。这是一个平均模型背后的想法，它是一个非常基本的集合案例。

你可以使用 Sklearn 的投票分类器轻松实现这一点，它甚至允许你为每个算法分配权重。

from sklearn.ensemble import VotingClassifier
ensemble=VotingClassifier(estimators=[('Decision Tree', decisiontree), ('Random Forest', forest)], 
                       voting='soft', weights=[2,1]).fit(train_X,train_Y)
print('The accuracy for DecisionTree and Random Forest is:',ensemble.score(test_X,test_Y))

我们可以根据性能分配权重或取平均值，即给算法设置相等的权重。

装袋方法:

装袋方法和前面的很像，但是我们不用威尔和格蕾丝，而是用速度和激情 1，2，3，4，5，6。这意味着我们不用不同的模型，而是用同一个模型的不同版本。

随机森林是一个著名的 bagging 模型，它使用了多棵树的变种。如果使用相同的树，那么它就是一个袋装决策树。

但是为什么装袋有效呢？我们不是又在做同样的事情吗？

让我们考虑一个模型正在训练，它注意到一个实例，一个蓝眼睛、红衬衫、带着笔记本电脑的白人男子坐在星巴克，我们需要找出他是一个有抱负的编剧的概率…现在，该模型似乎已经深入到无法预测它开始证明这种流行刻板印象的每一个实例的概率。每个符合上述描述的白人都不是编剧…..(他可能是 tho)

总的来说，当一个模型概括了一些它不应该概括的东西时，它有很高的方差，打包可以减轻这个问题

使用 Bagging 确保预测不会读取高方差。

bagging 模型中的每个模型(bag)彼此略有不同，并确保我们不会停留在非常深的表示上，并输出一个对测试集更友好的预测。

下面是随机森林的代码，一种装袋方法

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
train_x, test_x, train_y, test_y = train_test_split(dataset.drop('target'),dataset['target'])
trained_model = random_forest_classifier(train_x, train_y)
predictions = trained_model.predict(test_x)

增压方法:

因此，在前面的示例中，我们要么采用几个独立的模型并计算它们的平均值，要么计算它们的加权平均值，但如果我们考虑我们之前的模型表现如何，并将其合并到我们的下一个模型中，会怎么样呢…..有点像用以前模型的预测来推动新模型…好了，你知道了…这就是助推的作用。

此外，重要的是要注意，模型是按顺序添加到集合中的。Boosting 有时会通过减少偏差、方差和许多 kagglers 微调 boosting 算法来获得非常棒的结果。

基于重量的助力:

假设您正在训练一个模型，其中根据预测为每个预测的标签分配一个权重(好的预测意味着权重较小，坏的预测意味着权重较大)。这有点像因果报应，除了升压不是一个婊子。

这些权重在集合中的每个模型上累加，随着权重的增加，你明白你需要更好地预测它们，并且你开始将你的模型集中在它们上，而不是那些权重较低的模型上。这一直持续到达到最大精确度或最大模型数量。

这些重量有点像现实生活中的重量，一个人收获越多，自尊越低，因此需要去健身房，这里健身房是助推算法…..你总是需要在健身房得到激励…:)

例如:Adaboost，强分类器是权重低的地方，弱分类器是权重高的地方。Adaboost 旨在通过添加模型和纠正以前模型的错误，将弱分类器转换为强分类器(必修教科书定义)

*class* sklearn.ensemble.**AdaBoostClassifier**(*base_estimator=None*, *n_estimators=50*, *learning_rate=1.0*, *algorithm=’SAMME.R’*, *random_state=None)*

残基助推:

在这种类型的提升中，我们分配权重的绝对值(预测和实际标签之间的差异)，并将其作为新变量分配给下一个模型。但是为什么呢？。…..考虑以下情况

Actual value : 1
Predicted Val: 0.75
Weight       : 0.25For next model let use this weight to minimize the error in the next model where we predict the value

Whaaaaat 所以只要插入一个损失函数，像梯度下降…是的…这种方法也可以被称为梯度推进

这里梯度指的是有限差分，而不是导数

这种方法的一些优点

• 没有过度拟合(使用学习率)
• 我们不依赖单一的预测树(估计数)

为了防止过度拟合，我们可以采用深度学习的辍学概念，并将其应用于集成，这确保了随机性和正则化，并确保我们的模型能够很好地推广。即。如果我们在集合中构建了 4 棵树，那么在构建第五棵树时，我们会故意忽略 2 棵随机的树。例如:DART(漏失符合多重可加回归树)。

很多开发者用来赢得比赛的超级棒的助推算法是

• Xgboost (极限梯度提升)，
• Lighbgm (垂直增长的非常快速的梯度推进)
• Catboost(带有良好的初始参数，可以自动编码分类变量)。

希望你觉得这篇文章有用和有趣…..

两个月探索深度学习和计算机视觉

原文：https://towardsdatascience.com/two-months-exploring-deep-learning-and-computer-vision-3dcc84b2457f?source=collection_archive---------5-----------------------

I’ve been reading/note taking is using an iPad Pro and LiquidText

我决定熟悉计算机视觉和机器学习技术。作为一名 web 开发人员，我发现这个不断发展的领域令人兴奋，但是我没有任何使用这些技术的相关经验。我将开始为期两年的旅程来探索这个领域。如果你还没有读过，你可以在这里看到第 1 部分:从 webdev 到计算机视觉和地理。

—

I️最终通过探索 I️拥有的任何激发自己学习的机会来让自己动起来。我最初并没有停留在研究机器学习上，但我想回到对某个主题感到兴奋的状态。I️通过参加为期一天的加密货币学术会议开始了我的研究，到下午会议开始时，我意识到机器学习和计算机视觉对我来说更有意思。

入门指南

大约在一本关于深度学习和计算机视觉交叉领域的伟大著作出版的时候，I️启动了我的探索。来自 PyImageSearch.com 的作者Adrian rose Brock汇编了一部关于计算机视觉和深度学习的高级思想和低级应用的三卷巨著。在探索深度学习的过程中，I️遇到了对线性回归、朴素贝叶斯应用(I️现在意识到，I️已经听到这个名字有很多不同的发音)、随机森林/决策树学习以及所有其他我正在屠杀的东西的无数解释。

I️花了几周时间阅读这本书，并感觉 I️可以将我迄今为止阅读的所有不同的博客帖子与一系列数学概念、抽象概念和实际编程应用联系起来。我快速通读了这本书，并且对如何将这个领域作为一个整体有了更好的理解。我最大的收获是得出了这样的结论:I️想要巩固我自己的工具和硬件，以构建计算机视觉软件。

硬件实现

I️受到启发，得到了一台 Raspberry Pi 和 RPI 相机，I️可以用它来分析视频流。我一点也不知道设置树莓酱会花很长时间。最初，I️希望简单地启动并运行一个视频流，然后在我的电脑上处理视频。I️努力让树莓 Pi 操作系统工作起来。然后，一旦 I️意识到什么是错的，I️不小心安装了错误的图像驱动程序，并意外地安装了冲突的软件。I️最初认为这个过程会充满对相机图像的处理，结果却变成了一场耗时数小时的调试噩梦。

到目前为止，I️已经意识到这是机器学习的一个重要开始，而计算机视觉的“东西”是关于调试的。

第一步。得到一个想法。
第二步。开始寻找做这件事的工具。
第三步。安装所需的软件。
第四步。淹没在冲突和意外的包版本问题中。

https://aiyprojects.withgoogle.com/vision#list-of-materials

树莓派背后我最初的灵感是建立一个简单的设备，有一个摄像头和 GPS 信号的想法。这个想法是基于对未来有多少车辆，自动驾驶或车队车辆，将需要许多摄像头进行导航的思考。无论是出于保险目的还是为了基本功能，I️设想将会有大量的视频素材被创建和使用。在这个过程中，将会有大量的媒体储存库闲置不用，成为了解世界的丰富数据源。

I️最终探索了树莓派的计算机视觉能力，但从未像我希望的那样成功地获得任何有趣的工作。I️发现有许多更便宜的类似树莓派的设备，它们在比全尺寸树莓派更小的 PCB 板上同时具有互连性和相机功能。后来，I️意识到，与其走硬件路线，I️还不如用一部旧 iPhone，开发一些软件。

我在探索深度学习的硬件组件方面的短暂尝试让我意识到，我应该尽可能坚持软件。当软件部分没有解决时，包含一个新的变量只会增加复杂性。

开源工具

在寻找机器学习资源的第一个月，我发现了许多开源工具，它们使启动和运行变得非常容易。我知道方科技公司提供了许多专有服务，但我不确定他们如何与开源软件竞争。可以作为 SAAS 工具使用的图像识别和 OCR 工具来自 IBM、Google、Amazon 和 Microsoft，非常容易使用。令我惊讶的是，有很好的开源替代方案值得配置，以避免不必要的服务依赖。

例如，几年前，我推出了一个 iOS 应用程序，用来收集和分享涂鸦照片。我从带有地理标签的公开 API 中检索图片，比如 Instagram 和 Flickr。利用这些来源，我使用基本特征，如标签和位置数据，来区分图像是否真的是涂鸦。最初，我开始每周拉几千张照片，很快就增加到一个月几十万张。我很快注意到，我索引的许多图像不是涂鸦，而是对我试图培养的社区具有破坏性的图像。我无法阻止人们自拍的低质量照片或对工作不安全的糟糕标记的图像加载到人们的订阅源中。因此，我决定关闭整个项目。

#graffiti results on instagram

现在，有了机器学习服务和用于对象检测和裸体检测的开源实现，我可以推出自己的服务，轻松检查每张被索引的照片。以前，如果我支付一项服务来进行质量检查，我会在 API 费用上花费数百美元，如果不是数千美元的话。相反，我现在可以从一些“数据科学”AWS 盒子下载一个 AMI，并创建自己的 API 来检查不想要的图像内容。这对我来说遥不可及，甚至就在两年前。

概观

在很高的层面上，在经历这个过程之前，我觉得自己理论上理解了大部分的物体识别和机器学习过程。在开始将我一直在消费的所有机器学习内容之间的点连接起来的过程之后，我觉得我对我需要学习的概念更加清楚了。例如，我不仅仅知道线性代数对机器学习很重要，我现在理解了问题如何被分解成多维数组/矩阵，并被大量处理以寻找仅在理论上可表示的模式。之前，我知道在特性之间有一些抽象，以及它们如何被表示为可以在一系列评估项目之间进行比较的数字。现在，我更清楚地理解了在机器学习的背景下，维度是如何通过纯粹的事实来表示的，即有许多因素直接或间接相互关联。特征检测和评估的多维方面的矩阵数学对我来说仍然是一个谜，但是我能够理解高层次的概念。

The previously illegible network architecture graphs are now seemingly approachable.

具体来说，阅读 Adrian Rosebrock 的书给了我解读机器学习算法的盒线图的洞察力。深度学习网络架构的崩溃现在有些可以理解了。我还熟悉常用于测试各种图像识别模型的数据集(MNIST、CIFAR-10 和 ImageNet)，以及图像识别模型之间的差异(如 VGG-16、Inception 等)。

时机——公共资金

我认为现在学习机器学习和计算机视觉很重要的一个原因与我从这本书中学到的一个概念有关:政府在研究方面投入大量资金的领域将会有巨大的创新。目前，除了分配给特定机器学习相关项目的特定资金外，还有数亿美元以赠款和奖学金的形式花费在研究项目上。

Example of pix2pix algorithm applied to “cat-ness”. https://distill.pub/2017/aia/

除了政府支出，来自私人机构的公开研究似乎也在增长。目前存在的研究形式，来自大型科技公司和公共基金会，正在推动整个机器学习领域。我个人从未见过像 distill.pub 这样的出版物和 OpenAI foundation 这样的集体形式的私人机构资助的公共项目如此集中。他们所做的工作是无与伦比的。

可行的任务

回顾我一直在阅读的材料，我意识到我的记忆力已经开始衰退了。从现在开始，我要做更多的行动导向的阅读。我现在有一个装有 GPU 的盒子，所以我觉得在训练模型和处理数据集方面没有任何限制。

最近，我参加了一个由 Carto 主办的关于空间数据科学的大型会议。在那里，我非常清楚地意识到我在空间数据科学领域有多少知识。在会议之前，我只是把整个领域称为“地图定位数据的东西”。

我会继续努力在网上结识有相似兴趣的不同的人。我已经能够对我找到的住在纽约并写了与我当前搜索相关的中型帖子的人这样做了。最近，在探索如何构建一个 GPU 盒子时，我得以与一位机器学习探索伙伴共进早餐。

到一月中旬，我希望熟悉围绕涂鸦图像训练模型的技术框架。我认为至少，我希望有一组要处理的图像，将图像关联到的标签，以及对照已训练的标签交叉检查未索引图像的过程。

感谢 Jihii Jolly 纠正我的语法。

深度学习中不同类型卷积的介绍

原文：https://towardsdatascience.com/types-of-convolutions-in-deep-learning-717013397f4d?source=collection_archive---------0-----------------------

让我给你一个快速概述不同类型的卷积和他们的好处。为了简单起见，我只关注 2D 卷积。

回旋

首先，我们需要就定义卷积层的几个参数达成一致。

2D convolution using a kernel size of 3, stride of 1 and padding

• 内核大小:内核大小定义卷积的视野。2D 的常见选择是 3，即 3x3 像素。
• 步幅:步幅定义了内核遍历图像时的步长。虽然其默认值通常为 1，但我们可以使用步幅 2 对图像进行缩减采样，类似于 MaxPooling。
• 填充:填充定义如何处理样本的边框。(一半)填充卷积将保持空间输出维度等于输入维度，而如果内核大于 1，未填充卷积将裁剪掉一些边界。
• 输入&输出通道:卷积层取一定数量的输入通道(I)，计算出特定数量的输出通道(O)。这种层所需的参数可以通过 IOK 来计算，其中 K 等于内核中值的数量。

扩张的回旋

(又名 atrous 卷积)

2D convolution using a 3 kernel with a dilation rate of 2 and no padding

膨胀卷积为卷积层引入了另一个参数，称为膨胀率。这定义了内核中值之间的间距。膨胀率为 2 的 3×3 内核将具有与 5×5 内核相同的视野，同时仅使用 9 个参数。想象一下，取一个 5x5 的内核，每隔一行删除一列。

这以相同的计算成本提供了更宽的视野。膨胀卷积在实时分割领域特别流行。如果你需要一个宽广的视野并且不能负担多重卷积或者更大的内核，使用它们。

转置卷积

(又名去卷积或分数步长卷积)

有些资料来源使用反卷积这个名称，这是不恰当的，因为它不是反卷积。更糟糕的是，反进化确实存在，但它们在深度学习领域并不常见。实际的反卷积反转了卷积的过程。设想将一幅图像输入到一个卷积层中。现在拿出输出，把它扔进一个黑盒子里，你的原始图像又出来了。这个黑盒做反卷积。这是卷积层的数学逆运算。

转置卷积有些类似，因为它产生的空间分辨率与假设的反卷积图层相同。然而，对这些值执行的实际数学运算是不同的。转置卷积层执行常规卷积，但恢复其空间变换。

2D convolution with no padding, stride of 2 and kernel of 3

在这一点上你应该很困惑，所以让我们看一个具体的例子。一个 5x5 的图像被送入卷积层。步幅被设置为 2，填充被停用，并且内核是 3x3。这会产生一个 2x2 的图像。

如果我们想逆转这个过程，我们需要逆向数学运算，这样我们输入的每个像素就产生 9 个值。之后，我们以步长 2 遍历输出图像。这将是一个反卷积。

Transposed 2D convolution with no padding, stride of 2 and kernel of 3

转置卷积不会这样做。唯一的共同点是，它保证输出也将是 5x5 图像，同时仍执行正常的卷积运算。为了实现这一点，我们需要对输入进行一些花哨的填充。

正如你现在所能想象的，这一步不会逆转上面的过程。至少不考虑数值。

它仅仅从以前重建空间分辨率并执行卷积。这可能不是数学上的逆运算，但对于编码器-解码器架构来说，它仍然非常有用。这样，我们可以将图像的放大与卷积结合起来，而不是进行两个独立的过程。

可分卷积

在可分离卷积中，我们可以将核操作分成多个步骤。让我们将一个卷积表示为 y = conv(x，k) 其中 y 为输出图像， x 为输入图像， k 为内核。简单。接下来，我们假设 k 可以通过: k = k1.dot(k2) 来计算。这将使它成为一个可分离的卷积，因为我们可以通过对 k1 和 k2 进行 2 次 1D 卷积来得到相同的结果，而不是对 k 进行 2D 卷积。

Sobel X and Y filters

以图像处理中常用的 Sobel 核为例。通过将 vector [1，0，-1]和[1，2，1].T 相乘，可以得到相同的内核。在执行相同的操作时，这将需要 6 个而不是 9 个参数。上面的例子显示了所谓的空间可分卷积，据我所知，它没有用于深度学习。

编辑:实际上，人们可以通过堆叠 1xN 和 Nx1 内核层来创建非常类似于空间可分离卷积的东西。这是最近在一个叫做EffNet的架构中使用的，显示出有希望的结果。

在神经网络中，我们通常使用一种叫做**深度方向可分离卷积的东西。**这将在保持通道分离的同时执行空间卷积，然后执行深度卷积。在我看来，用一个例子最能理解。

假设我们在 16 个输入通道和 32 个输出通道上有一个 3×3 卷积层。具体发生的情况是，32 个 3×3 内核遍历 16 个通道中的每一个，从而产生 512(16×32)个特征图。接下来，我们通过将每个输入通道相加来合并 1 个特征图。因为我们可以这样做 32 次，我们得到了我们想要的 32 个输出通道。

对于同一个例子中的深度方向可分离卷积，我们遍历 16 个通道，每个通道具有 1 个 3×3 内核，给我们 16 个特征图。现在，在合并任何东西之前，我们用 32 个 1x1 卷积遍历这 16 个特征图，然后开始将它们加在一起。这导致 656 (16x3x3 + 16x32x1x1)个参数，而不是上面的 4608 (16x32x3x3)个参数。

该示例是深度方向可分离卷积的具体实现，其中所谓的深度乘数是 1。这是迄今为止此类层最常见的设置。

我们这样做是因为假设空间和深度信息可以分离。从例外模型的表现来看，这个理论似乎是可行的。深度方向可分离卷积也用于移动设备，因为它们有效地使用参数。

有问题吗？

这就结束了我们通过不同类型的回旋的小旅行。我希望这有助于对这件事有一个简要的了解。如果你还有任何问题，请发表评论，并查看GitHub 页面获取更多卷积动画。

市场组合建模中交互效应的类型

原文：https://towardsdatascience.com/types-of-interaction-effects-in-market-mix-modeling-mmm-95247f3de36e?source=collection_archive---------6-----------------------

Source: Pixabay

在这篇文章中，我想谈谈在市场组合模型中变量之间的各种类型的相互影响。

这篇文章是我在 MMM 上写的系列文章的延续。关于 MMM 的前三篇文章可以在这里、这里和这里找到

那么，回归中的交互作用效应是什么呢？

交互效应是两个或多个自变量对至少一个因变量的同时效应，其中它们的联合效应显著大于(或显著小于)各部分的总和。它有助于理解两个或多个自变量如何协同工作来影响因变量。

首先理解两个组成部分很重要——主效应和交互效应。

主要效果:

主效应是单个自变量对因变量的影响——忽略所有其他自变量的影响。

交互效果:

如上所述，两个或多个自变量对至少一个因变量的同时效应，其中它们的联合效应明显大于(或明显小于)各部分的总和。

我将把这篇文章限制在讨论两个变量之间的相互作用。

交互效果可以在两者之间:

I. 分类变量

二。 连续变量

三。 一个分类变量和一个连续变量

对于每一种情况，解释都会略有不同。

1。分类变量之间:

想象有人在努力减肥。减肥可能是锻炼或遵循饮食计划的结果，也可能是两者协同作用的结果。

以上数字表示以千克为单位的重量损失。

以上结果说明了什么？

结果表明，单独锻炼比节食计划更有效，体重减轻了 5 公斤

**二。**与锻炼和节食计划同时进行的情况(你的节食计划不起作用)相比，只有锻炼才能减轻更多体重

以上结果说明了什么？

这表明，当运动和饮食计划一起实施时，体重下降更高。所以，我们可以说，锻炼和饮食计划之间存在着相互作用。

**2。**连续变量间的

让我们来看一个显示主效应和交互效应分量的回归方程。

Y =β0+β1 * X1+β2 * X2+β3 * X1 x2

上述等式解释如下:

i. β1 是当 X2 等于 0 时 X1 对 Y 的影响，即当 X2 等于 0 时，X1 增加一个单位导致 Y 增加β1 个单位。

二。类似地，当 X1 等于 0 时，β2 是 X2 对 Y 的影响，即当 X1 等于 0 时，X2 增加一个单位导致 Y 增加β2 个单位。

三。在 X1 和 X2 都不为零的情况下，X1 对 Y 的影响取决于 X2，而 X2 对 Y 的影响取决于 X1。

为了更清楚，让我们用另一种格式重写上面的等式。

Y =β0+(β1+β3 * X2)X1+β2 * X2

=>Y =β0+β1 * X1+(β2+β3 * X1)X2

=> (β1 + β3 X2)是 X1 对 Y 的影响，它取决于 X2 的值*

=> (β2 + β3 X1)是 X2 对 Y 的影响，它取决于 X1 的值*

请注意，本文是针对用于市场组合建模的输入/变量而写的。上述概念是 MMM 的一种可能情况，其中输入值可能为零。

对于输入变量不能为零的情况，采取一些其他措施。一个例子可以是一个模型，其中一个人的体重被认为是一个回归变量。一个人的体重不能为零:)

3。 一个连续变量和一个分类变量

一个分类变量和一个连续变量之间的相互作用类似于两个连续变量。

让我们回到我们的回归方程:

Y =β0+β1 * X1+β2 * X2+β3 * X1 x2

其中 X1 是分类变量，比如说(女性= 1，男性= 0)

X2 =连续变量

• 当 X1 = 0 时，Y = β0 + β2X2*

= > X2 增加一个单位将导致男性 Y 增加β2 个单位

• *当 X1 = 1 时，Y = β0 + β1 + (β2 + β3)X2

= >女性在 X2 增加一个单位将导致 Y 增加β2 + β3 个单位

X2 对 Y 的影响女性高于男性(请参考下图 1)

Figure 1

MMM 中交互的解释:

1。两个分类变量:

让我们来看两个分类变量——季节性和一些产品的推出。

假设季节性和产品投放都与销售有积极的关系。季节性和以个人身份推出产品会带来销售。如果他们之间有互动效应，这可能会增加销售额。

Y = β0 + β1季节性+β2 产品投放+ β3季节性产品投放

=>Y =β0+β1+β2+β3

其中季节性和产品投放= 1

如果没有相互作用，Y = β0 + β1 + β2

2。两个连续变量:

MMM 中两个连续变量之间相互作用的例子可以是电视广告和数字广告一起对销售的影响。

因此，当存在交互项时，电视广告对销售的影响取决于数字广告，而数字广告对销售的影响取决于电视广告。

Y = β0 + β1电视广告+β2 数字广告+ β3电视广告数字广告- >正向互动术语

如果交互项为正，那么这两个变量的联合效应是协同的，因为它会导致额外的销售。建议这两种类型的广告应该同时进行，以获得更高的销售额。

Y = β0 + β1电视广告+β2 数字广告- β3电视广告数字广告- >负面互动术语

如果交互项是负的，那么交互组件会拿走一部分销售额，从而降低总销售额。在这种情况下，建议不要同时开展这两项活动，因为这会影响销售。(您的活动在客户中制造混乱:P)

请注意，这两种投入的主要影响是积极的，但综合影响具有负的β值，导致总销售额减少。

3。一个连续变量和一个分类变量

其中 X1 是分类变量，比如季节性(如果有季节性，则为 1，否则为 0)

X2 =连续变量:电视广告

Y =销售额

销售受到季节性和电视广告的影响，当它们一起作用时。

Y =β0+β1 季节性+ β2电视广告+ β3电视广告季节性**

在这种情况下，当季节性因素存在时，则:

Y =β0+β1+β2 电视广告+ β3电视广告

*=>Y =β0+β1+(β2+β3)电视广告

电视和季节性之间的相互作用导致了额外的销售。

这是一篇关于变量间交互作用的简介。互动效应本身就是一个巨大的话题。还有更多微妙之处。

请继续关注 MMM 上的更多文章…..

参考:

** [## 相互影响

对于不知情的人来说，调查似乎是一种容易设计和进行的研究，但是当学生和…

methods.sagepub.com](http://methods.sagepub.com/reference/encyclopedia-of-survey-research-methods/n226.xml)

如果你喜欢我的文章，给它一些掌声，或者更好地与你的朋友或同事分享。

页（page 的缩写）最近，很多人问我是否做市场组合建模/营销分析方面的咨询。

答案是肯定的。您可以将您的咨询问题发布到https://www.arymalabs.com/

你也可以在 LinkedIn 上联系我

【www.ridhimakumar.com】版权所有 2018 版权所有 版权所有。**

你应该知道的机器学习算法的类型

原文：https://towardsdatascience.com/types-of-machine-learning-algorithms-you-should-know-953a08248861?source=collection_archive---------0-----------------------

应我的朋友 Richaldo 的要求，在这篇文章中，我将解释机器学习算法的类型以及何时应该使用它们。我特别认为，了解机器学习算法的类型就像了解人工智能的全貌，以及该领域正在做的所有事情的目标是什么，并让你处于更好的位置来分解一个真正的问题并设计一个机器学习系统。

本帖中经常使用的术语:

• 标记数据:由一组训练示例组成的数据，其中每个示例是由输入和期望输出值组成的对(也称为监控信号、标签等
• **分类:**目标是预测离散值，例如{1，0}、{True，False}、{spam，not spam}。
• **回归:**目标是预测连续值，例如房价。

机器学习算法的类型

如何定义机器学习算法的类型有一些变化，但通常它们可以根据它们的目的分成几类，主要类别如下:

• 监督学习
• 无监督学习
• 半监督学习
• 强化学习

监督学习

• 我喜欢用函数逼近的概念来考虑监督学习，基本上我们训练一个算法，在过程的最后，我们选择最好地描述输入数据的函数，对于给定的 X，它对 y (X → y)做出最好的估计。大多数时候，我们无法找出总是做出正确预测的真正函数，其他原因是算法依赖于人类关于计算机应该如何学习的假设，这种假设引入了偏差，偏差是我将在另一篇文章中解释的主题。
• 在这里，人类专家充当教师，我们向计算机提供包含输入/预测的训练数据，我们向它显示正确的答案(输出),计算机应该能够从这些数据中学习模式。
• 监督学习算法试图对目标预测输出和输入特征之间的关系和依赖性进行建模，这样我们就可以根据它从以前的数据集中学习到的那些关系来预测新数据的输出值。

起草

• 预测模型
• 我们已经标记了数据
• 监督学习问题的主要类型包括回归和分类问题

常用算法列表

• 最近邻
• 朴素贝叶斯
• 决策树
• 线性回归
• 支持向量机(SVM)
• 神经网络

无监督学习

• 用未标记的数据训练计算机。
• 这里根本没有老师，实际上计算机在学习了数据模式后可能会教你新的东西，这些算法在人类专家不知道在数据中寻找什么的情况下特别有用。
• 是机器学习算法家族，主要用于模式检测和描述性建模。然而，这里没有输出类别或标签，算法可以基于它们来尝试对关系进行建模。这些算法尝试对输入数据使用技术来挖掘规则、检测模式，以及汇总和分组数据点，这些数据点有助于获得有意义的见解并向用户更好地描述数据。

起草

• 描述性模型
• 无监督学习算法的主要类型包括聚类算法和关联规则学习算法。

常用算法列表

• k-均值聚类，关联规则

半监督学习

在前两种类型中，要么数据集中的所有观察值都没有标签，要么所有观察值都有标签。半监督学习介于这两者之间。在许多实际情况下，标记的成本相当高，因为这需要熟练的人类专家来做。因此，在大多数观察值中没有标签但在少数观察值中存在标签的情况下，半监督算法是建模的最佳候选。这些方法利用了这样的思想，即使未标记数据的组成员是未知的，该数据也携带关于组参数的重要信息。

强化学习

方法的目的是利用从与环境的相互作用中收集的观察结果来采取行动，使回报最大化或风险最小化。强化学习算法(称为代理)以迭代的方式不断地从环境中学习。在这个过程中，代理从它的环境经验中学习，直到它探索所有可能的状态。

R 强化学习是机器学习的一种，因此也是人工智能的一个分支。它允许机器和软件代理自动确定特定上下文中的理想行为，以最大化其性能。需要简单的奖励反馈让代理学习它的行为；这就是所谓的强化信号。

这里有许多不同的算法来解决这个问题。事实上，强化学习是由特定类型的问题定义的，其所有解决方案都被归类为强化学习算法。在这个问题中，一个代理应该根据他当前的状态来决定最佳的行动。当这个步骤被重复时，这个问题被称为马尔可夫决策过程。

为了产生智能程序(也称为代理)，强化学习经历以下步骤:

1. 代理观察输入状态。
2. 决策功能用于使代理执行一个动作。
3. 行动完成后，行动者从环境中获得奖励或强化。
4. 存储关于奖励的状态-动作对信息。

常用算法列表

• q 学习
• 时差
• 深层敌对网络

使用案例:

强化学习算法的一些应用是计算机玩的棋盘游戏(象棋、围棋)、机器人手和无人驾驶汽车。

最终注释

有可能使用不同的标准来分类机器学习算法的类型，但我认为使用学习任务是很好的，以可视化 ML 的大画面，我相信根据你的问题和你手中的数据，你可以很容易地决定你将使用监督，无监督或强化学习。在接下来的文章中，我会给出更多关于每种机器学习算法的例子。

下面这张来自 en.proft.me 的图片或许能帮到你。

进一步阅读

• 机器学习算法之旅
• 机器学习算法精要(附 Python 和 R 代码)
• 有监督和无监督的学习算法有什么区别？
• (这个很好玩，解释得很好)

让我知道你对此的想法，如果你有你想看的主题的建议，请联系我们。

最后做的事

如果你喜欢这些作品，请留下你的掌声👏推荐这篇文章，让其他人也能看到。

优步司机调度优化

原文：https://towardsdatascience.com/uber-driver-schedule-optimization-62879ea41658?source=collection_archive---------5-----------------------

这个模型实现和图形可以在我的 Github 库中找到。

此外，非常感谢我的团队成员 Deep Prasad、Emily Xu 和 Sharlene Peng 为这个项目做出的贡献。

第 1 部分:导言

优步的关键价值主张之一是为他们的司机合作伙伴提供调度灵活性。根据 Beneson Strategy Group 的一份报告，73%的司机更喜欢有一份可以让他们选择时间表的工作。司机可以利用这种灵活性，在可用时间内最大化他们的预期收入。为此，优步提供了客户需求热图，使司机能够瞄准高需求区域，提供更高的出行概率，从而获得更高的预期收入。

然而，没有现成的方法来确定从特定位置开始的行程是否值得为该行程花费时间。例如，由于交通而花费较长时间但需求较高的行程可能会导致总行程较少，价值较低。另一方面，需求较少但持续快速的旅行可能更有价值。因此，平衡某个位置的需求和从该位置出发的行程所需时间最符合驾驶员的利益。

为了解决这一缺口，我们试图使用混合整数规划(MIP)创建一个调度优化模型。

第 2 部分:数据收集

两个数据集用于确定需求和行程持续时间。因为优步的需求数据不可用，所以 DC 出租车载客数据被用作需求的替代数据。持续时间由优步运动数据集确定。

DC 出租车数据-需求

数据集来自 DC 开放数据中心。它描述了以坐标表示的特定位置的单个出租车行程。从 1 月到 3 月，该数据集包含 10，843 个不同位置的总共 5，546，786 次拾取。

为了将数据离散化并缩小问题的规模，我们需要将皮卡分类到高需求区域。首先，计算每个位置的取货数量。然后，为了定义区域，我们选择了提货次数最多的前 100 个位置(见图 1–1 ),因为它们占提货总数的 30%。MATLAB 的 kmeans 函数用于将计数聚类成 5 个区域质心(见图 1–2)。基于到其他四个区域的最小欧几里德距离计算每个区域的半径。

Table 1: High-Demand Region Parameters

Figure 1–1: Taxicab Pickups in D.C.

Figure 1–2: High Demand Pickup Regions in D.C.

由于我们只比较区域内的行程，因此接货计数被过滤为只包括从五个区域之一始发且目的地与始发地在同一区域内的行程。然后对一天中的时间、一周中的日期和地区的计数进行平均和汇总。下面是一个经过清理的离散化数据集的示例。

Table 2: Sample of Demand Data (cleaned) used for Model

优步移动数据—行程持续时间

该数据集来自优步的“优步运动”倡议(见附录 A)。它描述了每个始发地-目的地区域对的平均、最小和最大行程持续时间。优步运动的区域小于之前确定的五个高需求区域。为了使这两个数据集具有可比性，对起点-目的地对进行了过滤，以仅包括完全落在五个区域之一内的区域，并且这些区域的目的地与起点在同一区域内(见图 2)。然后计算五个区域中每个区域的平均、最小和最大旅行持续时间。与需求数据类似，这些值是按一天中的时间、一周中的日期和地区聚合的。数据集的样本可以在下面找到。

Figure 2: High Demand regions over-laid over Uber Regions

Table: Sample of Trip Duration Data (cleaned) used for the model

第 3 部分:方法

使用需求和行程持续时间数据，开发了一个混合整数规划模型来为驾驶员找到最佳驾驶计划。MIP 是线性优化程序，一旦得到一个解，其中一些变量可以是整数，而另一些则不可以。

最著名的 MIP 和我们的类似:T2 背包问题。在我们的例子中，背包的容量代表了优步司机为他们的日程安排分配的“总时间”。我们希望最大化预期收入。开发了以下 MIP:

目标函数

该模型的目标函数是使司机在一周的工作时间内获得的收入最大化。这是通过最大化每个推荐区域 j 和时间段 I 的预期收入之和来实现的。预期收入项 R_的计算公式如下:

其中我们假设新出行的概率均匀分布在 0.5 和 1 之间，因为这 5 个区域是基于高需求选择的。基于这一假设，可以使用需求来分配概率(见附录 B)。

通过使用每组区域 j 和时间段 I 中可能的最小行程次数，找到了最坏情况下给定时间的行程次数。因为时间段被细分为 2 小时时间段，所以最小行程次数可以近似为:

决策变量和参数

模型中的决策变量为X_{ij}，其中 I 和 j 分别表示对应的时间和区域。X_{ij}是布尔变量，其中 1 表示选择了时间 I 的区域 j。模型中使用了以下参数:

• R_ —时间 I 期间驾驶员在区域 j 可获得的预期收入
• _ —布尔变量，用于指示驱动程序在块 I 期间是否可用
• B_ —布尔变量，表示驱动器是否能够在区域 j 中工作
• T_ —驾驶员一周可以工作的最大小时数

限制

优步因其日程安排的灵活性而具有吸引力。优步司机可以随时随地工作。为了准确地模拟灵活性，MIP 受到以下限制:

• 约束条件 1 和 2 确保生成的最佳排班不包括驾驶员不愿意工作的区域或他们不可用的时间。
• 在约束 1 中，A _ =表示驾驶员可以在时间段 I 驾驶，否则为 0。
• 在约束 2 中，B _ =表示驾驶员愿意在区域 j 中驾驶，否则为 0。
• 常数 Tmax 确保排班的总小时数不会超过驾驶员每周愿意工作的最大小时数。
• 约束条件 4 确保每个时间段只推荐一个区域。
• 约束 5 确保决策变量 X_和参数 A_和 B_是二进制的。

MATLAB 实现

为了实际实现该模型，在 MATLAB 中编写了一个中央程序，该程序准备 MIP 并使用 intlinprog 函数求解它。中央程序需要 6 个参数，每个参数对应于上面列出的决策变量。该问题必须为 intlinprog 公式化，它解决以下形式的问题:

代码可以在 Launch_IP.m 和 Solve_IP.m 中找到

MATLAB:数据提取方法

首先，从Taxi Pickup Data和Uber Movement Data提取的两个数据集在工作日、小时和地区上被连接。数据集的每一行代表给定地区在给定工作日给定小时的交通状况。使用readtable()函数提取所需的子集数据。

MATLAB:约束

使用这些数据，通过分三步构建 A 和 b 矩阵，为 intlinprog 制定了约束条件。第一步创建维度为1 x n的向量 A1，b1，表示优步司机愿意工作的小时数。第二步构建矩阵 A2、b2，确保不会同时推荐两个区域。最后，A1 被附加到 A2，b1 被附加到 b2，以形成最终的矩阵 A 和 b。

第二个约束要求推荐的区域在驾驶员愿意前往的区域内。如果驾驶员不愿意在特定区域驾驶，则在创建约束矩阵之前，该区域的所有持续时间、交通和约束参数将被移除。因此，没有必要将区域偏好纳入约束矩阵。该模型还假设从一个区域到下一个区域的时间可以忽略不计。在时间段i期间，驾驶员可能预期在区域 B，但是对于时间段i+1，驾驶员在 12 英里之外的区域 C。在区域之间旅行的时间成本可以在未来的迭代中实现。

MATLAB:目标函数

为了表示目标函数，建立两个向量并相乘。第一个向量表示在时间 I 期间在当前区域获得客户的概率，第二个向量表示时间段i中的估计行程数。使用以下代码行找到最终的目标函数:

f = transpose(P_new_customer.*Min_Trips).*avg_revenue_trip;

其中avg_revenue_trip根据 2014 年优步研究得出的每小时收入中值和每小时出行信息，约为 12 美元。

现在，使用适当的公式，可以通过intlinprog()用构建的 A、b 和 f 向量找到最优解。上限和下限分别设置为 1 和 0。

第 4 部分:结果

该模型能够在给定一个驾驶员的指定参数的情况下生成周计划。例如:

Model Inputs — Driver’s Availability

Model Outputs — Ranked Recommendation to the Driver

为了评估模型性能，考虑了两个指标:模型性能和优化。具体来说，该团队想知道当最大工作时间(Tmax)、时间段和区域的数量增加时，收入和计算时间会受到怎样的影响。

模型性能

为了确保稳定的结果，该模型对于每个实例运行 500 次，并且记录平均目标值和计算时间。为避免偏差，每个实例的时间段和区域都是随机选择的。发现计算时间随着时间段数量的增加而增加，但随着最大小时数的增加而减少(见附录 C)。

最佳性

随着可用时间段的数量在 1-42 之间变化，最佳收入在 450-545 美元/周之间变化(见图 3)。可用时间段数量的增加代表了驾驶员对我们定义的时间段的调度灵活性的增加。这种正相关关系表明，司机的时间安排越灵活，他们期望获得的收入就越多。

Figure 3: Optimal Revenue/Week Increases as Driver Availability Increases

只有当包含多个区域时，可用区域数量的增加才会导致收入的增加，这表明更多的可用区域不会对收入产生重大影响(参见附录 C)。

第五部分:讨论

随着可用时间段数量的增加，收入增加有两个潜在的原因。

首先，是“偶然收入”。这意味着收入的增加是由于服务时间的多样性增加，平均而言，在更多的高收入产生时间内驾驶的结果。

或者，人们可以简单地赚更多的钱，因为他们开车更频繁了。为了确定原因，团队绘制了每周最大工作时间增加时的收入图(见图 4)。增加最大工作时间似乎显著增加了司机的收入，这表明一个人驾驶的时间段对收入的影响远不如他们驾驶的频率大。

此外，通过比较预期收益和实际收益，验证了模型的有效性。根据众包信息，一名优步司机每周工作 30 小时，每周收入约为 772 美元。根据我们的模型，最佳最坏情况下的预期收入约为 1900 美元。这明显更高，表明我们的模型是对当前驾驶员驾驶模式的显著改进。

延长

该模型的结果有直观的意义，并显示了更广泛的应用潜力。可以将该模型推广到任何城市，而不仅仅是华盛顿。该团队还希望将“竞争”组件纳入该模型。如果几个司机同时被推荐到同一个地区，竞争将会增加，每个司机得到一次旅行的可能性会降低。根据团队建立的公式，这明显降低了预期收入，并且会将最佳解决方案错误地呈现为“最佳”。一个更先进的模型将能够平衡它在给定地区和时间给出的建议数量，并“重新安排”司机，以平衡某个地区有建议的司机数量。

第六部分:结论

基于 MIP 模型的结果和解释，该团队能够宣称它在预期收入方面为优步驱动程序带来了有意义的价值。模型规定的时间段数与司机的预期收入之间存在正相关关系。为了增加他们的收入，司机应该在尽可能多的时间段可用。现在，司机通过做出数据驱动的决策，而不是使用试探法来选择“最佳”位置为客户服务，从而比其他司机更胜一筹。有了模型规定的可行和方便的时间表，司机们现在可以把他们的工作想象成一个具有竞争优势的有利可图的行业。

第 7 部分:参考

1优步新闻编辑室，“BSG 报告:驱动者路线图”。【在线】。可用:https://news room . Uber . com/WP-content/uploads/2015/01/BSG _ 优步 _Report.pdf 。[访问时间:2017 年 4 月 16 日]。

2Opendata.dc.gov，“出租车旅行”。【在线】。可用:【http://opendata.dc.gov/datasets?q=taxi】T2。[访问时间:2017 年 4 月 16 日]。

3Movement.uber.com，“优步运动:让我们找到更聪明的前进方式”，2017 年。【在线】。可用:【https://movement.uber.com/cities】T4。[访问时间:2017 年 4 月 16 日]。

[4] J. Hall 和 A. Krueger，“优步在美国的司机伙伴的劳动力市场分析”，2017 年。【在线】。可用:https://time dot com . files . WordPress . com/2015/01/Uber _ driver-partners _ hall _ kreuger _ 2015 . pdf。[访问时间:2017 年 4 月 16 日]。

5我和优步一起开车，《家——我和优步一起开车》，2017。【在线】。可用:http://www.idrivewithuber.com。[访问时间:2017 年 4 月 16 日]。

第八部分问答

为什么是 matlab？

更多的是个人喜好。Matlab 在解决优化问题方面非常专业(也很快)，就像这种情况下的 MIP 模型，我熟悉它的语法。Python 确实有几个 MIP 的库，但是我不熟悉。项目中的数据处理和分析主要是用 Python 实现的。从技术上讲，用 Python 可以完成从处理到优化的整个循环。

如果所有的司机都遵循“最优解”，会发生什么

随着越来越多的司机采用这种“工具”，竞争优势将逐渐消失。在一个边缘案例中，如果我们达到了一个均衡，在这个均衡中，所有需求水平相同的区域的拥挤状态都是相同的，那么这个工具将变得无用。然而，这在现实中永远不会发生，至少现在是这样，所以总有一些改进的空间。

这只是概念层面。我希望看到我们能够在现实中实现这种智能和优化的资源配置。

附录

附录 A

以下是团队访问优步旅行持续时间数据时必须使用的优步移动接口。因为界面限制团队必须手动选择时间段和位置，所以团队必须缩小所选位置的范围。

附录 B

以下是在 MATLAB 中实现的公式，用于计算新行程的概率:

• P_和 P_是用于计算新出行概率的均匀分布的下限和上限(在我们的例子中，为 0.5 和 1)
• D_和 D_是该区域和时间段的最大和最小拾取计数。

附录 C

以下是补充图表，描述了给定变化参数的计算时间和目标函数的分析。

Increase in revenue with more regions leveling off after two regions

Increasing computation time with more time blocks

Decreasing computation time with higher T_

Decreasing computation time with more regions

优步地图技术讲座

原文：https://towardsdatascience.com/uber-maps-tech-talk-8df91c300f80?source=collection_archive---------5-----------------------

Pic Credit

除非你是出于某种神秘或其他原因远离科技生活的人，否则你一定非常习惯我所说的地图对话——“你能分享位置吗？”，“地图显示路上交通繁忙！”等等。数字和网络地图服务是一个随着时间和技术不断发展和完善的领域。虽然其中一个原因是技术和计算的进步，但另一个主要原因是这是一个非常具有挑战性且尚未解决的问题。这就是有趣的地方，也是这个优步地图技术演讲非常有趣的地方。

在我们今天进行的两次信息丰富的谈话之前，有一个关于优步·班加罗工程团队中从事技术工作的女性的视频，还有一个为答对的人准备的奖品。如果你想知道，不，我没有赢过！首先发言的是地图团队的产品经理 Ankit。在几个月前的一次早期演讲中，演讲者解释了用户打开优步应用程序到旅程结束之间发生的事件和操作的数量。定位骑手和驾驶员并提供准确的导航路线对于平稳的骑行非常重要。Ankit 带我们经历了每一步，从估计用户位置开始，搜索地点和地址，计算费用和预计到达时间。当用户打开应用程序时，首先需要的是他/她的位置。这涉及到许多需要考虑的特征，比如用户是在室内还是室外，用户是否在地面以上的某个建筑中，或者其他类似的场景。这是通过使用 GPS、位置预测模型和 WiFi 指纹识别来实现的。所有这些都是为了让那个小蓝点出现在优步地图的正确位置上！

为了便于搜索放置地点或地址，应该考虑许多因素。该地图可以使用用户的历史数据(如果有的话)，显示具有准确位置的热门地点，显示附近的优步游乐设施的快照等。当涉及到 Uber Eats 时，还有其他不同的情况需要考虑。下一步是票价计算，必须非常准确。估计行程时间、行程距离、通行费的存在、当前用户位置周围优步乘车的供应以及当前乘车的需求都是估计费用的决定因素。如果这听起来很复杂，那么想想不同类型的乘车会有什么不同——UberGo、UberPool 和最近的 ExpressPool。虽然 UberPool 和 ExpressPool 都允许拼车，但 ExpressPool 从最近的上车点提供乘车服务，乘客可以步行到该地点。这不仅有助于骑车人到达一个可以乘坐的地方，而且也更便宜。

Pic Credit

每一步都建立在前一步的基础上，并增加了一些复杂性。ETA 预测是下一步，对于不同的乘坐模式是不同的。对于 UberGo/UberPool，只有一个司机到达骑手的预计到达时间。在快速拼车的情况下，还应考虑骑车人到达上车点所需的时间。ETA 计算几乎没有挑战。如果交通发生不可预见的变化怎么办？还是突然的路障？如果司机的网络不稳定怎么办？前两个导致 ETA 的重新计算。为了处理不稳定的网络，缓存的路径在驾驶员端被重用。因此，即使司机失去连接，也有办法让地图在没有连接的情况下工作。一旦驾驶开始，后台会不断优化路线，帮助驾驶员选择最佳路线到达目的地。骑手和所选路线的历史路线记录都用于此目的。在结束演讲之前，Ankit 透露了优步的多式联运计划，该计划适应使用不同模式的乘坐，不仅包括四轮车，还包括自行车、滑板车等。(以防你不知道，优步正在投资滑板车租赁初创公司 Lime，这家公司也有谷歌的支持)

"在座有多少人研究过地图？"Gaurang Khetan 开始讲话时问道。很少有人举手。因此，如果你想做一些有挑战性的、有趣的、对流行产品有直接影响的事情，那么地图就是你的了。是什么使它成为如此困难和具有挑战性的问题？地图和收集的数据一样好，好的数据很难得到。有不同的来源可以获取开发地图所需的数据，其中包括多家供应商。随着物理世界的不断变化，地图需要不断更新和改进。世界上不同的国家有不同的分配地址的惯例和结构。此外，很难衡量地图和路线的正确性。跟随数字地图时迷路并不罕见。除了所有这些原因，用于最佳路线和基于地理的搜索的算法需要非常快速、高效和可扩展。

地图数据来自不同的图层、不同的来源，包括多种类型，如道路网络、商业地点、地址、物理空间(如商场和建筑)以及自然特征(如湖泊)。数据量不仅巨大，而且非常多样化。这使得使用地图进行全球展示成为一个永无止境的过程。另一个问题是，“我们如何为一个没有地图数据的国家或地方建立地图数据？”你应该花几分钟思考一下，然后自己回答。邮政数据、政府数据、GPS 跟踪、多个供应商、手动驾驶和路线、卫星视图、众包等是收集/创建地图数据的一些方式。多少数据才够？随着城市化的发展和技术的扩展，城市的位置必须被很好地绘制，路线必须被完全理解，对吗？虽然这在某种程度上可能是真的，但有一个问题是城市地区特有的——城市峡谷。

Pic Credit

在市区或高楼林立的地方，卫星信号在直接到达 GPS 接收器之前可能会受到阻碍。如果有高层建筑在卫星的视线范围内，就会发生这种情况。简而言之，GPS 使用许多围绕地球轨道运行的卫星(30 颗或更多),并传输 GPS 接收器用于位置识别的信号。这些信号会被传播路径上的建筑物阻挡或反射。当这种情况发生时，会导致位置信息出错。这种误差从几米到 50 米或更大不等。上面的图像就是这样一个例子。

Pic Credit

为了克服这个问题，优步地图使用信噪比(SNR)。如果卫星的 SNR 值较低，这意味着没有到相应卫星的直接视线，并且位置信息会有一些误差。当它很高时，必须有一个清晰的卫星视线，因此位置信息将是准确的。在上图中，我们可以看到左侧的点在卫星 C 和 D 的视线范围内，但不在卫星 B 的视线范围内。同样，右侧的点在卫星 B 和 C 的直接视线范围内，但不在卫星 D 的视线范围内。此信息非常有用，同样可用于确定该位置位于道路的左侧还是右侧。

很明显，在地图方面，有太多的东西需要了解、学习、尝试和改进，而这正是优步正在做的事情。它不仅仅使用谷歌地图和 GPS 提供的原始信息。地图是优步大学的一个活跃的研究领域，他们正在不断完善它。作为一个例子来了解优步如何使位置信息更好，见下面的原始 GPS 提供的位置信息(红色的)和优步的改进 GPS(蓝色)的比较。虽然改进后的 GPS 提供了更好的导航，但原始的 GPS 却无处不在。

这是我今年参加的第三次优步科技讲座，这些讲座非常有趣。虽然众所周知，地图和图表不容易解决问题，而且还在不断改进，但了解这么多关于一个非常依赖这些领域的公司目前如何在这些领域工作和研究的信息真的很好。会谈结束后，我们还愉快地进行了交流。演讲者和其他几个目前在优步工作的人加入了我们，帮助我们解答问题和疑惑。感谢优步组织了这次技术讲座。

顺便说一句，他们的办公室很酷！！

这是我写的关于我参加的第一次优步科技演讲的博客的链接

如果你喜欢到目前为止在这篇文章中读到的内容，并且想了解优步发生的一切，我推荐你查看这个来自优步的博客，并且在 Twitter 上关注 @ubereng ，他们在 Twitter 上发布了关于他们最近的研究工作和开源工具的消息。

感谢阅读！！！

连接:LinkedIn，Twitter和我的 博客 。

优步的自主车祸调查

原文：https://towardsdatascience.com/ubers-autonomous-car-accident-investigation-57fcc88cb6e7?source=collection_archive---------7-----------------------

3 月 19 日，一个故事震惊了自动驾驶汽车行业，当时优步的一辆自动驾驶汽车在亚利桑那州坦佩撞倒了一名女子。这是被自动驾驶汽车撞上后的第一起死亡事件。这严重地对自动驾驶汽车提供的安全功能的所有说法产生了严重的怀疑。3 月 23 日，Tempe 警方发布了一段事故视频，这让许多事情都成了问题。完整视频可以在 youtube 这里观看。

Image Source (https://www.aol.com/article/news/2018/03/19/woman-dies-in-arizona-after-being-hit-by-uber-self-driving-car/23389700/)

分析 Dashcam 视频

完整视频可点击查看。(来源-美国广播公司行动新闻)。让我们看一下从仪表板上捕捉到的第一张图像，以分析我们获得的所有信息。

5 seconds before collision.

这里有几点需要注意-:
1。车道线清晰可见。
2。远处的路上有车，还有一些建筑物的灯光。
3。路上有路灯！
4。用肉眼，除了远处的汽车什么也看不见。

撇开这些细节-
1。汽车以每小时 38 英里的速度行驶，限速 45 英里。( 来源 ) 2。汽车在近光灯上行驶。

2 seconds before the collision

跳跃到 0.07，碰撞前 2 秒，可以观察到在左侧和右侧，我们有路灯，所以有足够的光线，但在左侧也有道路的黑色部分。

Left Street Light Passes by in the next frame of the same second

我们仍然处于第七秒，仍然没有任何行人的迹象，看着左边的路灯在这一帧中经过。

还在第 7 秒，两个灯都过去了。现在，这是我们第一次看到行人的脚步。

碰撞前 1 秒，从仪表板摄像头可以清楚地看到行人或有障碍物。

嗯，我们在第八秒，现在我们也可以看到行人和自行车的下半部分。

现在，这个女人和她的自行车清晰可见。但是那辆车减速了，甚至试图减速了吗？不要！再次需要注意的重要一点是，这位女士穿着黑色衬衫/夹克。但是自行车或者那个女人的白鞋子呢？

我有意跳过了第 9 帧的图像。即使在第 9 秒，赛车也没有减速！那就奇怪了！！

相机不是问题

确实，在撞击前 50 到 60 帧的时候，有人观察到了这个女人，但是机器仍然无法捕捉和减速！但这里的重点不是关于相机，它很暗，相机可能会错过这一点，而且上半部分是黑色的，也可能会错过这一点。自行车甚至完全看不见。现在主要问题来了。激光雷达怎么了？激光雷达是自动驾驶汽车使用的最昂贵的设备之一，它没有反应！！任何人都可以争辩雷达可能会错过一些信息，但激光雷达不会。激光雷达把那个女人当成噪音了吗？嗯，看起来只有这个，如果是这样，我们肯定有一个用例要处理。这里还有一点需要思考，那就是这个女人甚至一秒钟都没有意识到车的存在！

激光雷达没有工作，好吧，我们对雷达没有期望，但是它也没有工作。即使发现了自行车，照相机也坏了。这是不可接受的，需要进行详细的调查，需要了解激光雷达把这个女人当成了什么，为什么相机的输入被丢弃了。所有传感器和技术的融合失败了 3 秒钟，这是非常令人惊讶的！！还有，视频素材不够！

谁有错的问题仍然存在。**司机有错吗？**从内饰视图中可以清楚地看到，在碰撞发生前，驾驶员正在向下看。在任何这种情况下控制汽车是她的责任，但我相信即使是一个正常的司机也无法避免事故，这就是我们制造自动驾驶汽车的确切原因，以避免司机的错误。现场非常黑暗，不幸的是，这个女人在错误的时间出现在了错误的地点。如果她能从一个街灯足够亮的地方穿过去，她可能会得救。但是现在问题来了，我们有分析过的录像，但是谁有错呢？优步，女人，技术？

好吧，现在有一件事非常清楚，自动驾驶汽车行业需要严格的测试来重新赢得人们的信任。此外，需要像我们在空难调查中那样对此类事件进行详细的调查，并且应该在各个参与者之间分享，以提高这个行业的安全标准。

请随意分享你的观点。

Ubuntu +深度学习软件安装指南

原文：https://towardsdatascience.com/ubuntu-deep-learning-software-installation-guide-fdae09f79903?source=collection_archive---------0-----------------------

我最近在报读 Udacity 的自动驾驶汽车工程师 Nanodegree 后，造了一台深度学习机器。你可以在这里阅读我的构建:花 800 美元构建一个深度学习平台。在这篇文章中，我将描述从一个干净的构建到训练深度神经网络的必要步骤。有很多好的安装指南——特别是来自 floydhub 的这个,大部分内容都是基于它——但是我发现自己不得不挖掘许多不同的资源来正确安装所有的东西。本文的目标是将所有必要的资源整合到一个地方。

系统检查

即使在安装操作系统之前，您也应该执行一些基本的检查，以确保您的系统正常启动和运行。为此，我建议遵循 Paul 的硬件 YouTube 频道中的关于新 PC 构建的前 5 件事。他继续安装 Windows，但视频的前半部分适用于任何机器，不管是什么操作系统。

人的本质

首先下载 Ubuntu 16.04.2 LTS ，Ubuntu 最新的长期支持版本。然后，用 Ubuntu ISO 创建一个可启动的 u 盘。如果你在 macOS 上，你可以遵循 Ubuntu 官方说明这里，或者如果你在 Windows 上，你可以遵循这里。一旦你把 Ubuntu ISO 加载到你的 u 盘上，把它插入你的新版本并启动机器。要安装 Ubuntu，你需要进入启动菜单，对我来说是 F11 键，然后选择从 u 盘启动。从那里，您可以简单地按照屏幕上的安装说明。你也可以参考 Ubuntu 的社区 wiki 快速指南:从 USB 记忆棒安装 Ubuntu了解更多细节。

基础

从终端运行以下命令来更新软件包并安装一些基本软件:

sudo apt-get update
sudo apt-get upgrade
sudo apt-get install build-essential cmake g++ gfortran git vim pkg-config python-dev software-properties-common wget
sudo apt-get autoremove
sudo rm -rf /var/lib/apt/lists/*

Nvidia 驱动程序

您需要根据您的 GPU 型号下载正确的驱动程序，您可以使用以下命令进行检查:

lspci | grep -i nvidia

查看专有 GPU 驱动程序 PPA 库，找到您的 GPU 的当前版本。在撰写本文时，GeForce 10 系列的最新版本是 381.22，但我选择了 375.66，这是当前的长期分支版本。使用以下命令安装驱动程序:

sudo add-apt-repository ppa:graphics-drivers/ppa
sudo apt-get update
sudo apt-get install nvidia-375

然后重新启动计算机:

sudo shutdown -r now

要再次检查驱动程序是否已正确安装:

cat /proc/driver/nvidia/version

库达

从 Nvidia 的网站下载 CUDA 8.0 工具包。转到下载目录(或者您选择保存它的地方)并安装 CUDA:

sudo dpkg -i cuda-repo-ubuntu1604*amd64.deb
sudo apt-get update
sudo apt-get install cuda

将 CUDA 添加到环境变量:

echo 'export PATH=/usr/local/cuda/bin:$PATH' >> ~/.bashrc
echo 'export LD_LIBRARY_PATH=/usr/local/cuda/lib64:$LD_LIBRARY_PATH' >> ~/.bashrc
source ~/.bashrc

检查是否安装了正确版本的 CUDA:

nvcc -V

重新启动计算机:

sudo shutdown -r now

cuDNN

从 Nvidia 的网站下载 cuDNN 库。在下载 cuDNN 之前，您需要首先注册 Nvidia 的开发者计划。他们说这可能需要几天的时间，但是我几乎立刻就获得了访问权限。在撰写本文时，cuDNN v5.1 是 TensorFlow 官方支持的版本，所以除非你知道 v6.0 受支持，否则不要发布(他们目前正在开发)。下载后，转到下载目录提取并复制文件:

tar xvf cudnn*.tgz
cd cuda
sudo cp -P */*.h /usr/local/cuda/include/
sudo cp -P */libcudnn* /usr/local/cuda/lib64/
sudo chmod a+r /usr/local/cuda/lib64/libcudnn*

Anaconda +包

从 Continuum 站点下载 Anaconda 安装程序。我选择了 Python 2.7 版本，但是您可以选择任何您想要的版本作为您的默认 Python:

bash Anaconda2-4.4.0-Linux-x86_64.sh

当安装程序询问您是否想将 Anaconda 添加到您的路径中时，回答“是”(除非您不想将它作为您的默认 Python)。一旦安装了 Anaconda，就可以用所有必要的深度学习库创建一个新的 conda 环境。我将使用 Udacity 的初学者工具包作为一个例子，因为这是我在许多项目中使用的。从CarND-term 1-Starter-Kit下载(或复制粘贴)environment-gpu.yml 文件。您可以在文件的顶部随意更改环境的名称。从保存环境-gpu.yml 文件的目录中:

conda env create **-**f environment-gpu**.**yml

要激活您的新环境:

source activate carnd-term1

现在，您可以通过运行 TensorFlow 的内置 MNIST 示例模型(不再适用于 TensorFlow 版本≥ 1.0)进行测试，以确保一切正常工作。请注意，以下命令将在首次运行时自动下载 12 MB MNIST 数据集:

python -m tensorflow.models.image.mnist.convolutional

如果在这一点上一切正常，那么恭喜你——你现在已经准备好对热狗进行分类了！

http://www.foodandwine.com/news/silicon-valleys-hot-dog-identifying-app-very-real

UCSF 科学家利用人工智能发现创伤性脑损伤的特征

原文：https://towardsdatascience.com/ucsf-scientists-use-artificial-intelligence-to-uncover-hallmarks-of-traumatic-brain-injury-a672ae75704a?source=collection_archive---------5-----------------------

我们在 UCSF 大学的长期合作者几周前刚刚发表了一篇论文，题为“使用 PLOS 一号中的拓扑数据分析揭示创伤性脑损伤(TBI)中的精确表型-生物标记关联”。UCSF 也发布了一份新闻稿。这是我们与 UCSF 合作的第二份出版物(以前的《自然》论文、快公司文章和我们的以前的博客)。这项研究得到了美国国立卫生研究院——国家神经疾病和中风研究所的资助。这些分析可能为 TBI 患者的未来临床试验中的患者分层和治疗计划提供一种可靠的方法。我已经在另一个博客中写了这项研究。

创伤性脑损伤是一种复杂的疾病，通常根据临床体征和症状来描述。最近的成像和分子生物标记创新为改善护理提供了机会，结合了病理解剖和分子机制。用于 TBI 诊断和患者分层的不同数据是一个挑战。来自扎克伯格旧金山总医院创伤中心、匹兹堡大学医学中心和德克萨斯州奥斯汀大学医学中心 Brackenridge 的急性创伤性脑损伤患者参与了这项研究。创伤性脑损伤的转化研究和临床知识(TRACK-TBI)试点多中心研究招募了 586 名急性 TBI 患者，并收集了研究人群的不同公共数据元素(TBI-CDEs)，包括影像学、遗传学和临床结果。这些 CDEs 包含 944 个变量，包括人口统计学、临床表现、影像学和心理测试。

该论文阐述了机器智能(MI)如何揭示患者结果中的数据驱动模式，以识别潜在的恢复生物标志物，这可以使用更传统的单变量统计测试方法，显著预测 TBI 后患者结果的恢复。MI 算法在多维空间中组织并绘制了 TBI 患者的数据，确定了轻度 TBI 患者的一个子集，该子集具有与损伤后 3 个月和 6 个月的不利结果相关的特定多变量表型。进一步的分析显示，该患者亚组具有较高的创伤后应激障碍(PTSD)发生率，并且富含几种与细胞对应激和 DNA 损伤的反应以及纹状体多巴胺加工相关的独特遗传多态性。最后，MI 确定了一个独特的诊断亚组，该亚组由轻度 TBI 后出现不良结果的患者组成，这些患者可通过特定基因多态性的存在进行显著预测。

如果你想合作，请联系我们在 collaborators@ayasdi.com

Udacity 无人驾驶汽车纳米度项目 10 —模型预测控制

原文：https://towardsdatascience.com/udacity-self-driving-car-nanodegree-project-10-model-predictive-control-e9b4195d3f9?source=collection_archive---------3-----------------------

Udacity 自动驾驶汽车工程师纳米学位项目的第十个项目，也是第二学期的期末项目，题为“模型预测控制”(MPC)。MPC 将 PID 控制的概念提升到无数个层次，随之而来的是无数倍的复杂性。不过，Udacity 将大部分复杂性卸载到了 IPOPT 和 CPPAD 包中。

像 PID 控制和行为克隆项目一样，这个项目的目标是在 Udacity 提供的模拟器中导航一条轨道。我很高兴看到他们从“湖”赛道上获得了一些额外的里程(明白吗？).这三个项目都需要我们的代码通过 websocket 与模拟器通信，根据它提供的数据向模拟器发送转向和油门命令。在行为克隆中，它提供相机馈送，在 PID 控制中，它提供跨轨道误差(CTE，大约是从轨道中心线的距离)，这次它提供遥测(位置、速度、方向)和未来一段轨道的几个航路点。这个项目的奖金挑战原来是强制性的(什么？！):一旦我们让我们的控制器工作，我们必须在发送控制命令之前投入 100 毫秒的延迟，以模拟我们在现实世界中可能遇到的延迟类型。

首先要做的是对提供的路点拟合一条曲线，最好是在它们已经从轨迹坐标转换到车辆视点之后，以简化未来的计算。我称之为最佳拟合曲线。然后，IPOPT 和 CPPAD 软件包可用于计算最佳轨迹及其相关的驱动命令，以便以最佳拟合最小化误差。你可能会想，“那么，为什么不遵循最合适的呢？”当然，这就是我们在 PID 控制中所做的事情，但现在我们知道接下来会发生什么，可以更聪明地规划我们的控制。当你开车转弯时，你并不完全是九十度，对吗？或许更像这样？

Image credit: Udacity

MPC 可以考虑车辆的运动模型，在给定一组约束的情况下，根据车辆运动的限制以及定义我们希望车辆如何移动的成本组合(如保持接近最佳拟合和所需方向，或防止车辆过快猛打方向盘)，规划出有意义的路径。

优化只考虑短时间内的航路点，因为这是我们真正需要计划的(就我们的执行器控制而言)。我们可以调整优化器在其计划中使用的离散时间点的数量，以及它们之间的时间间隔，以便它可以在合理的时间内计算出最佳计划(我们当然希望它足够快，以实时控制汽车)。优化器需要一个巨大的一维向量，其中包括计划中每个时间步的状态变量和约束，以及总成本函数——坦率地说，不是特别直观，但易于管理。

由于未来时间步长的变量取决于先前的时间步长，因此它们的约束利用了车辆的运动学模型。运动学模型包括车辆的 x 和 y 坐标、方位角(psi)和速度，以及跨轨迹误差和 psi 误差(epsi)。执行器输出只是加速度和 delta(转向角)。该模型将前一时间步的状态和动作结合起来，根据以下公式计算当前时间步的状态:

经过一些调试和调整成本函数，我的车在赛道上行驶。是时候通过增加延迟来彻底摧毁它了——这就是所发生的事情。我处理它的方法是双重的(不仅仅是限制速度):最初的运动学方程依赖于前一个时间步的驱动，但是有 100 毫秒的延迟(恰好是我的时间步间隔)，驱动在另一个时间步之后应用，所以我改变了方程来说明这一点。(注意:我的项目评审员建议了一个更简单的解决方案——在运行 MPC 求解器方法之前，将汽车的当前状态预测到未来 100 毫秒。例如，按照现在的情况，传递给解算器的我的汽车的 x 和 y 位置是0，0，但是 100 毫秒后它应该是不同的。)此外，除了课程中建议的成本函数，我还加入了一个惩罚速度和转向组合的成本，这导致了更多的可控转弯。

下面是一段轻松愉快的视频回顾:

这个项目的源代码可以在我的 GitHub 上找到

原载于 2017 年 6 月 30 日【http://jeremyshannon.com/2017/06/30/udacity-sdcnd-mpc.html】。**

Udacity 无人驾驶汽车纳米学位项目 4 —高级车道发现

原文：https://towardsdatascience.com/udacity-self-driving-car-nanodegree-project-4-advanced-lane-finding-f4492136a19d?source=collection_archive---------2-----------------------

欢迎来到“妈妈报告”(嗨妈妈！);如果技术术语和晦涩难懂的语言更符合你的风格，那么 请点击这里 ，否则请尽情享受吧！

Udacity 自动驾驶汽车工程师 Nanodegree 第一学期的第四个项目建立在第一个项目的之上，超过了第二个项目和第三个项目。虽然这看起来很明显，因为它们都涉及到寻找车道线，但这背后的原因是项目 2 和项目 3 向我们介绍了深度学习的新奇之处，几乎可以为我们编写代码，而项目 1 和项目 4 依赖于更传统的计算机视觉技术来非常明确地了解我们如何从输入到输出。这几乎让人失望——就像用键盘换铅笔一样——但是人们会说:(我听起来像总统吗？)公司仍然依赖这些技术，所以它绝对值得学习(并且仍然有趣和具有挑战性), OpenCV 库是承担所有重担的人。

"所以让我们拿个仪表盘找些车道！"你是说？好吧，等一下，特克斯。你不能随便就开始找车道。首先，你用的摄像机？它扭曲了图像。你可能看不出来，但这是真的！看:

幸运的是，这可以通过几张棋盘照片和 OpenCV 函数findChessboardCorners和calibrateCamera来纠正(对于单个相机/镜头)。看看这个:

我知道——对我来说它看起来也几乎一样，但失真在图像的角落最明显(看看底部汽车引擎盖形状的差异)。

现在我们可以开始有趣的事情了。下一步是应用透视变换来获得前方车道的鸟瞰图。它看起来是这样的:

我可能做了不必要的努力来使我的透视变换恰到好处(使直线在最终的鸟瞰图中完全垂直)，但是因为变换是根据相同的规则反向的，所以最终可能没什么关系。

接下来，我探索了一些不同的颜色转换和渐变阈值，试图隔离车道线，并生成一个二进制图像，其中车道线处为 1(白色)，其他地方为 0(黑色)。这无疑是整个过程中最微妙的部分，对光线条件和褪色非常敏感(更不用说那些该死的白色汽车了！)在路上。我不会用细节来烦你；我只想说这是我在这个项目上花了大部分时间的地方。最后，我结合了一个在 Lab 色彩空间的 B 通道上提取黄线的阈值和一个在 HLS 色彩空间的 L 通道上提取白色的阈值。这是每一个的样子:

这是它们在几幅测试图像上的组合:

不算太寒酸！

现在，聪明的一点是:搜索整个图像来识别哪些像素属于左车道和右车道是不必要的(并且计算量很大),因此我们计算了二进制图像下半部分的直方图，如下所示:

左半部分和右半部分的峰值为我们提供了车道线开始位置的良好估计，因此我们可以从底部开始搜索小窗口，并基本上沿着车道线一直到顶部，直到识别出每条线中的所有像素。然后可以将多项式曲线应用于识别的像素，瞧！

不仅如此，使用前一帧的拟合并在附近搜索，可以更容易地在视频的连续帧中找到像素，如下所示:

它只是在多项式线和多边形中着色以填充它们之间的通道，应用反向透视变换，并将结果与原始图像相结合。我们还做了一些简单的计算和转换，以确定道路的曲率半径和汽车离车道中心的距离。这是最终的结果:

这是我应用于下面链接的视频的管道，带有一点平滑(整合来自过去几帧的信息)和健全性检查以拒绝异常值(例如忽略不在特定距离内的拟合)。

该视频可爱地展示了图像处理管道中的步骤:

这里有一个链接到我的视频结果，这里有一个奖励视频，其中有一些额外的诊断信息，在这里你可以看到算法与困难的照明和路面条件进行斗争(在某些情况下会崩溃)。

再说一遍，如果你感兴趣的是技术类的东西， 去这里 。

最初发表于 ..//2017/03/03/uda city-SD CND-advanced-lane-finding . html2017 年 3 月 3 日。

Tableau 认证终极指南

原文：https://towardsdatascience.com/ultimate-guide-to-getting-certified-in-tableau-5bd2df7d0c7d?source=collection_archive---------3-----------------------

作为一个 tableau 的忠实支持者，一个认为 tableau 是商业智能和可视化领域最好的产品的人，我很自然地想办法提高我的 Tableau 知识，这样我就可以随时成为任何 Tableau 相关查询的联系人。在提高知识的同时，你会有一个两难的时刻，如果你现在就去争取一个更公开的认可，而不仅仅局限于你的“工作认可”，或者你应该坚持只与工作相关的认可。

虽然工作认可总是好的，并且是我们非常努力工作的事情，但获得证书使我们能够在社区中被听到，并有助于围绕数据科学、分析和 BI 进行建设性的讨论。从对整体形象的增值角度来看，证书并不是普遍得到认可的，因为如果你与 10 位经理谈论“他们在审查/选择求职面试简历时是否重视证书”，很肯定你会得到 5 个肯定，5 个否定。因此，学生和入门级的专业人士经常处于进退两难的境地，但考虑到我对画面的热爱，我不在其中😊。

自从我加入锡拉丘兹大学的 iSchool 以来，我一直在考虑获得 tableau 的认证，以及大多数招聘职位如何要求一个人知道至少一种标准的 BI 工具，无论是 Tableau、Microstrategy、PowerBI 还是其他工具。BI 工具上的所有这些招聘信息、讲座和博客点燃了我继续学习的好奇心，我决定要在 Tableau 获得认证。我在 2016 年 9 月决定了这一点，但由于时间表和事件的顺序，我未能将此事置于其他承诺之上。但最后，我在去年(2017 年)感恩节假期后恢复活力后做了这件事，并预订了日期。如果你已经犹豫了一段时间，不知道这样做的价值以及你是否会有时间，你应该只预订考试的日期。如果你不预订日期，你永远不会有时间！简单。

是什么启发我写了一篇关于 Tableau 证书的博客？

互联网上有大量的博客和资源，经过上个月的搜索，我觉得，我拥有的资源帮助我在考试中获得了超过 90%的分数。可以肯定的是，下面的资源不会让你获得 Tableau 认证，但也会帮助你成长为 Tableau 开发人员。

在我们深入研究计划以及如何从可用的免费/付费资源中学习之前，让我们先为从未听说过 Tableau 认证的人谈谈内务管理。

这里我们讨论的是 Tableau 桌面认证，请注意，Tableau 也是 Tableau 服务器认证，但这是另一天。

即使在 Tableau 桌面认证套件中，我们也根据您对该工具的理解和专业水平提供了几个选项。

1) Tableau 桌面合格助理(TDQA)

• 推荐给具有至少 5 个月使用该工具的实践经验的人，以及了解 SQL 基础知识并理解数据库、连接和标准数据分析术语的人(即使您以前没有 Tableau 的经验，但愿意学习，您也可以获得认证)。
• 费用:250 美元(不幸的是，没有学生折扣)
• 时间限制:2 小时(额外 30 分钟用于设置和调查)
• 问题数量:36
• 问题的划分:70 次动手/30 次基于工具本身的理论
• 及格分数:75%(注:每道题根据难度高低权重不同，动手更有价值)
• Tableau 考试指南:下载 Tableau 考试指南

2) Tableau 桌面认证专家:

• 推荐给有丰富 Tableau 桌面经验的人。建议有 9 个月以上的经验。与 TDQA 不同，该证书包括动手操作、书面回答和在 Tableau 桌面中构建/保存解决方案
• 成本:600 美元(同样没有折扣)
• 时间限制:3 小时(同样，额外的 30-45 分钟用于设置和调查)
• 通过和评分:根据详细的评分标准手动评分

备考:

该博客安全地假设您从未使用过 Tableau 或者对该工具的访问权限有限。如果您是一名学生，并且没有访问该工具的权限， tableau 为学生提供一年的免费桌面工具访问权限。对于非学生和专业人士， tableau 提供 14 天的试用期这可能不够。但在博文的最后，我会分享免费获得 6 个月 Tableau 桌面访问的方法。继续读！

开始准备:

建议您做的第一件事是浏览 Tableau 桌面证书指南中的每个单词。pdf 做得非常好，列出了证书的知识，考试中测量的详细技能，并为您提供了样本问题和解决方案，以验证您对所要求技能的理解。对于该指南对于掌握证书的重要性，我怎么强调都不为过。实际上，在我准备的时候，我每周都会浏览 pdf 文档，并在我有绝对信心的技能和仍然需要改进的技能上打勾。一旦你复习完考试指南，就该记下你缺乏必要知识的地方，并开始复习。

我已经尝试将资源分为初级和高级级别，以便在正确的时间访问正确的资源。

初学者资源:

1. Tableau 学习 : 话不多说至于 Tableau 官网的免费培训对我备考有多大帮助。如果你看过考试指南，你会知道技能测试部分已经被分成数据连接，分别组织&简化数据 Tableau Learning 以类似的方式很好地组织了他们的培训。浏览 Tableau Desktop 下的所有视频两次，是的，两次，因为仅仅浏览一次是不够的，当你像我一样重新观看时，你会在观看时学到更多的技巧和诀窍，并提高你对该工具的理解。

**费用:**免费

2)【Tableau 10 A-Z 初学者】Kirill Eramenko**:**Kirill Eramenko 的初学者课程不是很适合专注于 Tableau 证书，如 Tableau Learning 和 Lukas Halim 的初学者 Tableau(描述如下)，但该课程很好地介绍了 Tableau 10 的所有功能，该课程最好的部分是它很实用。一旦你完成了这个课程，你将从一个专业人士的角度学习 tableau，而不是作为一个仅仅是为了获得认证而学习 tableau 的学生。

通常需要 199.99 美元，但你总能在 Udemy online 上获得 90-95 折的优惠券，其中之一就是“JNY1202”

3)Lukas Halim**:**与 Kirill 的课程不同，本课程是专门为获得 Tableau 桌面认证而设计的。视频讲座充其量也就相当一般，我不会责怪 Lukas，因为课程的主要重点是让学生获得认证，而不是成为 Tableau 专家。本课程的好处是它非常紧密地遵循考试指南中的“技能衡量”部分，这允许您遵循考试的结构，并对所问的技能/问题更加自信。

课程中最精彩的部分？

Tableau 桌面资格助理考试的小测验和两个完整长度的模拟测试。我将在高级部分谈论考试，因为如果你还不熟悉这个工具本身，谈论模拟考试是没有意义的。

**费用:**与上面的建议类似，你可以用“JNY1202”这样的代码花 10-12 美元就能进入课程

4. 安迪是数据学校的主教练，负责在 tableau 和 alteryx 上培训超过 1000 名个人。他是 Tableau 禅师，也是一个了不起的老师。在这段视频中，Andy 和他的 tableau/data school 学生团队分享了他们参加 Tableau QA 考试的经历，并单独谈论了技能部分，分享了一些如何快速学习这些技能的技巧&以及在考试中会遇到什么。我不得不说，这是一个相当不错的长达一小时的视频。

**花费:**你 1 个小时的时间

5. Tableau 知识库 : 虽然没有遵循这些建议的特定格式，但我过去常常只是将“衡量技能”中的一行复制粘贴到谷歌上，然后阅读 Tableau 知识库上的文章。考虑到考试包含 30%的理论问题/权重，我们可以使用互联网搜索答案，阅读 Tableau 知识库是一个很好的培养习惯。

成本:免费

初学者部分到此为止。如果你遵循先完成 Tableau 学习，然后转到 Kirill 的 Tableau 10 A-Z，然后转到 Lukas Halim 的课程的模式，你现在应该足够自信，能够尝试 Tableau QA 考试指南中 50-60%以上的问题。

高级资源:

一旦您尝试了 Tableau QA 指南中的问题，就该进入高级部分了，这些部分将涵盖细节层次计算、集合/组、分析窗格等高级主题:

1. Tableau 10 基里尔·叶列缅科 : 我非常喜欢基里尔的教学方式和他亲自动手的方法，即使是最简单的概念。在本高级培训中，Kirill 将带您浏览 5 个仪表板，涵盖一些非常高级的内容，如详细程度计算、高级计算(如字符串处理、数据处理、高级连接、数据混合)、仪表板操作、集合和组！同样，与 Kirill 之前的课程一样，他不会带着让您获得认证的心态教授课程，他会从专业分析师的角度教授，以及分析师将如何处理最终利益相关方提出的数据问题。一个一定要看的视频课程。

成本:$ 10–12

2)Coursera 的数据可视化与 Tableau 交流: 杜克大学的这门课程是我最喜欢的在线学习 Tableau 的课程之一。本课程最精彩的部分是，教师使用的数据集都是经过深思熟虑的，并且是实际操作的。数据集包括 H1B 工作签证申请数据和由 Dognition 提供的真实商业数据集，Dognition 是一家狗训练公司，它很乐意向学生提供关于他们公司的数据。

通过注册该课程，您还可以免费使用**tableau 6 个月，**即使您没有注册他们的付费证书选项。如果你因为没有 tableau 访问权限而坚持自己，那就去做吧

费用:免费，如果你需要完成证书

3)Simplilearn 的模拟测试:在你完成了上面链接的高级视频课程后，你现在已经准备好测试你的知识并了解你的弱点在哪里。如果你在网上搜索 tableau 考试的模拟试题，你会感到失望。在你准备期末考试之前，没有很多资源可以测试你的知识。Simplilearn 提供 2 个模拟测试样本，在您提交个人详细信息后，测试 1 即可公开获取，而如果您需要访问测试 2，则必须注册 Simplilearn 提供的 Tableau 课程的免费试用。当您尝试本模拟测试中的问题时，您会慢慢意识到这些问题的水平比考试指南低一个等级。真正的考试符合考试指南的水平，但由于没有太多的模拟考试，任何可以测试你的知识的考试都更有价值。如果你在这些测试中得分在 90%以上，不要太高兴，真正的模拟测试如下所述。

**费用:**免费或 7 天免费试用

4. 学习 Tableau 实践考试 1:Tableau 桌面合格协理考试的事实上的实践考试。一旦你完成了所有的课程链接，Lukas Halim 的课程测试和 Simplilearn 的练习测试，并复习了测试之后，是时候进行真正的测试了！如果我说这个测试不值得，那我就是在撒谎。这是最接近 Tableau 的考试(包括练习 2，如下所述)。如果你真的对认证很认真的话，这是必须的。Lukas 做了一项了不起的工作，他真的提供了能很好地引起考试共鸣的数据集和问题。它的挑战性足以让你思考，不像 Simplilearn 测试，但也足够简单，让你对自己的准备感觉良好。卢卡斯创造了这些测试。

这项测试的另一个出色之处是 Lukas 为所有问题提供了一个出色的解决方案，而 simplilearn 没有做到这一点。这些解决方案指南帮助你了解错误的解决方案，并帮助你以更好的方式学习

**费用:**包含在您购买的 Lukas Halim 课程中，如果您没有兴趣购买课程，Lukas 还有独立测试包(比课程贵)。LearningTableau.com 有详细报道

5. 高级概念:

如果我必须根据不同的难度等级来评价 tableau 考试，我会说 25%的问题是高级概念，我会在下面列出。这些概念是上述课程的一部分，但是单个概念的博客/视频可以让你更加关注它们，从而对它们更加好奇。你不仅要为考试准备这些高级概念，而且作为一个 tableau 的重度用户，我个人也在日常的 tableau 工作中使用一些概念。

a.**细节层次计算:**这是考试中最重要的概念之一。你不会得到超过 2-3 个关于这个概念的问题，但是考虑到它的用例以及 LOD 的强大，当然建议你尽可能多的了解它们。如果你浏览下面的链接，你会获得足够的关于 LOD 及其用例的知识。在考试中，您可能会遇到关于群组分析(或每个群组贡献了多少收入/销售额)、客户订单频率、客户获取的问题。

这里有一个提示，它将在考试中帮助你:只要学习固定 LOD，甚至不用担心包含或排除 LOD，包含和排除能做的，固定也能做。所以要成为固定 LOD 的专家。这里有一些关于它们的好资源

2. **Top N/Nested N/Nested 排序:**另一个重要的概念，你可以很容易地想到关于 Top N/Nested N 的几个问题。这并不难，但如果没有给予适当的尊重，就很容易被忽略。以下资源将帮助您理解它。

c.**表计算:**大多数 tableau 新用户都知道计算字段，如 sum、average、datediff、datepart 等，但 tableau 中计算的另一个重要方面是表计算。这里有一些关于它们的好资源:

d.**参数及其用例:**虽然您不会被要求“专门”创建一个参数来解决任何问题，但它是您希望添加到 tableau 目录中的一个特性。最终利益相关者喜欢摆弄数据和控制数据点/参数的能力。tableau 中的参数赋予了他们这种超能力。

(我几乎每隔一周就重温一次这个视频，以获得如何在我的仪表板中使用参数的想法，它太棒了！只需将它加入书签以备将来使用)

e.**分析窗格:**分析窗格覆盖了考试总分数的 15%以上，是失分是犯罪的部分之一。如果你知道均值、中位数、众数、标准差、回归是什么意思，这里应该不会失分。一些好的资源:

f.**其他重要概念:**虽然我没有任何推荐的概念列表资源，但上面的课程很好地涵盖了它们:

• 集合、组和创建组合集合
• 高级过滤
• 数据混合
• 如何利用交叉表
• 数据透视表
• 拆分，自定义拆分
• 连接计算
• 绿色药丸和蓝色药丸的区别

5. 学习表格练习测试 2 :已经学得够多了，该准备考试了。你怎么知道你是否准备好考试了呢？通过尝试卢卡斯·哈利姆的模拟测试 2。这两个测试都是最接近真实的测试。如果你直接从 udemy 上购买课程，你可以直接自动参加这两项考试，总共可以节省 20 美元。当尝试这个测试时，确保尝试复制真实的考试环境，这基本上意味着在两个小时内进行测试，没有手机，没有干扰。只有你和练习测试可以访问互联网，但没有电子邮件和聊天应用程序。一旦你完成了，即使你的分数低于 75%也不要担心，我有朋友在第二次测试中的分数低于 50%，但却通过了考试。只要确保你把事情放在你的下巴上，并仔细阅读解决方案指南。你现在准备好了！及时行乐！

杂项提示:

• 该考试是监考考试，您可以在方便的时候进行，这意味着您可以在任何地方进行考试，唯一的问题是它将被监考。
• 考试将在安装了相关数据文件和 tableau 桌面的虚拟机中进行。请务必查看数据文件。
• 另一个非常重要的提示是，我一直给与我一起学习的其他人，总是用你的问题编号来重命名你的工作表。不要把它放在第一页、第二页……当到了复习的时候，你会浪费时间去找问题的工作表。
• 在开始解决问题之前，在您的工作簿中添加一个仪表板，并在视图中拖动一个文本元素，开始记录需要检查的问题/要点，稍后再回来。
• 一开始的问题让我很惊讶。这些问题的难度让我大吃一惊，我花了将近 20 分钟才解决了 3 个问题。所以，如果你也遇到了这种情况，不要担心，在最初的困难之后，问题会变得很简单，很容易解决。
• 即使你对理论问题 100%有信心，也不要在没有搜索的情况下给它打分。提问的方式会利用你的疏忽，这样你就会失分。
• 仪表板问题很简单，但问题的微小细节很容易被忽略。小心点。
• 当你在 chrome 和 tableau 之间切换时，利用分屏可以节省一些时间。chrome 考试标签是移动自适应的，所以如果你调整考试标签的大小，你仍然可以阅读较小的 chrome 标签中的所有文本，而无需滚动。这给了我很大的帮助，也让我在回答问题的时候可以多次阅读问题。

继续你的学习:

考完了吗？已经认证了？恭喜你。你做到了。但是下一步，如果你想继续学习 Tableau 并从这一点开始成长。以下资源对我很有帮助，我很确定你也能从中学到很多。

• tableau 大会直播:#Data17 即 Tableau 大会是 Tableau 每年举办的最大的数据大会之一。如果你是一名学生，参加会议的费用会很高，但是如果你能接触到会议上讨论的内容，如果你能接触到会议上教授的实践练习册，会怎么样呢？
• 是啊。你可以！前往 tclive.tableau.com向最优秀的人学习！每年他们都会用最新的#数据视频和 handson 工作簿更新内容。
• #改头换面星期一:需要一些不断的灵感和数据来挑战自己？网络上每周都有一些非常好的社交项目，其中之一是安迪·克里贝尔和伊娃·默里的#改头换面星期一，请访问#改头换面星期一，了解更多关于社区仪表盘的信息，让你大吃一惊！
• 即社会公益:类似于#改头换面星期一，但具有独特的挑战。点击了解更多信息
• Tableau Tips 周二:每周一篇关于一些高级 Tableau 概念的博客文章，由 Andy Kriebel 亲自解释！他们的一些令人惊叹的博客帖子包括 KPI 和迷你图，创建棒棒糖图表

这应该足以满足你的好奇心，以了解更多关于 Tableau。如果你觉得这篇博文足够有价值，点击分享按钮，或者在 Medium 上阅读时鼓掌，或者在 LinkedIn 上添加我，让我们在这里创建一个#数据社区，互相学习。

原载于 2018 年 10 月 1 日www.linkedin.com。

CTR 预测的不确定性:一个阐明所有不确定性的模型

原文：https://towardsdatascience.com/uncertainty-for-ctr-prediction-one-model-to-clarify-them-all-8cb0aa5ed2?source=collection_archive---------21-----------------------

在本系列的第一篇文章的中，我们讨论了会影响模型的三种不确定性——数据不确定性、模型不确定性和测量不确定性。在的第二篇文章中，我们具体讨论了处理模型不确定性的各种方法。然后，在我们的第三篇文章中，我们展示了如何利用模型的不确定性来鼓励在推荐系统中探索新项目。

如果我们可以使用一个统一的模型，以一种有原则的方式处理所有三种类型的不确定性，这不是很好吗？在这篇文章中，我们将向你展示我们在 Taboola 是如何实现一个神经网络来估计一个物品与用户相关的概率，以及这个预测的不确定性。

让我们跳到深水处

一张图胜过千言万语，不是吗？一张包含一千个神经元的图片？…

无论如何，这是我们使用的模型。该模型由几个模块组成。我们将解释每个人的目标，然后画面会变得更清晰…

项目模块

该模型试图预测一个项目被点击的概率，即 CTR(点击率)。为此，我们有一个模块，它获取项目的特征作为输入，如标题和缩略图，并输出一个密集的表示——如果你愿意，也可以是一个数字向量。

一旦模型被训练，这个向量将包含从项目中提取的重要信息。

上下文模块

我们说过模型预测了一个项目被点击的概率，对吗？但是这个项目是在什么样的背景下展示的呢？

上下文可能意味着很多事情——出版商、用户、一天中的时间等等。该模块获取上下文的特征作为输入。然后它输出上下文的密集表示。

融合模块

因此，我们从项目和上下文中提取了信息。当然，这两者之间有一些互动。例如，与金融出版商相比，体育出版商中关于足球的项目可能具有更高的点击率。

这个模块将两种表示融合成一种，类似于协同过滤。

估计模块

最后，我们有一个模块，其目标是预测 CTR。此外，它还估计了 CTR 估计的不确定性。

我猜你对这个模块是如何工作的不太确定，所以让我们来解释一下。

我们将带您了解我们提到的三种不确定性，并向您展示我们的模型是如何处理每一种不确定性的。首先，让我们解决数据的不确定性。

资料不确定

让我们用一些在回归任务上训练的通用神经网络。一个常见的损失函数是 MSE——均方误差。我们喜欢这种损失，因为它是直观的，对不对？您希望最小化误差…但事实证明，当您最小化 MSE 时，您隐含地最大化了数据的似然性-假设标签正态分布，具有固定的标准偏差𝝈.这个𝝈是数据中固有的噪声。

我们可以做的一件事是通过引入一个新的节点，我们称之为𝝈.，显式地最大化可能性将其插入似然方程并让梯度传播使得该节点能够学习输出数据噪声。

我们没有取得任何不同，对吗？我们得到了与最初基于 MSE 的模型相同的结果。但是，现在我们可以引入从最后一层到𝝈:的链路

现在我们开始有趣的事情了！𝝈现在是输入的函数。这意味着模型可以学习将不同级别的数据不确定性与不同的输入关联起来。

我们可以让这个模型更加强大。我们可以估计高斯分布的混合物，而不是估计高斯分布。我们加入的高斯函数越多，模型的容量就越大——也更容易过度拟合，所以要小心。

这种架构被称为 MDN——混合密度网络。它是由主教等人于 1994 年引进的。以下是它捕捉到的一个例子:

我们有两组类似的项目——一组是关于购物的，另一组是关于运动的。

事实证明，购物项目往往有更多的可变点击率——可能是由于趋势。事实上，如果我们要求模型估计每组中一个项目的不确定性(图中的虚线)，我们得到的购物不确定性比运动更高。

所以数据不确定性已经过去了。下一步是什么？

测量不确定度

这个有点复杂。在的第一篇文章中，我们解释了有时候测量会有噪音。这可能会导致有噪声的要素甚至有噪声的标注。在我们的例子中，我们的标签 y 是一个项目的经验性点击率——到目前为止它被点击的次数除以它被显示的次数。

假设一个物品的真实 CTR 是 y* —也就是说，没有测量噪声。如果我们在上下文中无限次显示该项目，这将是 CTR。但是时间是有限的(至少我们有的时间是有限的)，所以我们只展示了有限的次数。我们测量了一个观察到的 CTR y。这个 y 有测量噪声——我们用𝜺.表示

接下来，我们假设𝜺呈正态分布，标准偏差为𝝈𝜺。r 的𝝈𝜺函数——我们展示物品的次数。r 越大，𝝈𝜺越小，这使得 y 更类似于 y*。

在一天结束时，在我们把你从数学细节中解救出来(你可以在我们的论文中找到)之后，我们得到这个可能性等式:

这与混合高斯分布的 MDN 架构中的可能性相同，但有一点不同，误差项分为两部分:

• 数据不确定性(𝝈i)
• 测量不确定度(𝝈𝜺)

既然模型能够用不同的术语解释每个不确定性，数据不确定性就不会被测量不确定性所污染。

除了能够以更好的方式解释数据，这允许我们在训练过程中使用更多的数据。这是因为在这项工作之前，我们过滤掉了太多噪音的数据。

最后但并不是最不重要的

在前一篇文章中，我们讨论了如何处理模型不确定性。我们描述的方法之一是在推理时使用 dropout。

能够估计模型的不确定性使我们能够更好地理解模型由于缺乏数据而不知道的东西。所以让我们来测试一下吧！

让我们看看独特的标题是否与高不确定性有关。我们将把训练集中的每个标题映射到一个密集表示(例如，平均 word2vec 嵌入)，并期望该模型对唯一标题不太确定，唯一标题是映射到嵌入空间的稀疏区域的标题。

为了测试它，我们通过计算 KDE(核密度估计)来计算稀疏和密集区域。这是一种估计我们空间的 PDF(概率密度函数)的方法。接下来，我们要求模型估计与每个标题相关的不确定性。事实证明，该模型在稀疏区域确实具有更高的不确定性！

很好…如果我们向模型显示更多稀疏区域的标题，会发生什么？会不会对这些区域比较确定？让我们来测试一下！

我们取了一堆类似的关于汽车的标题，把它们从训练集中去掉了。实际上，它改变了他们在空间中的区域，从密集变为稀疏。接下来，我们估计了这些标题的模型不确定性。不出所料，不确定性很高。

最后，我们只将其中一个标题添加到训练集中，并重新训练该模型。令我们满意的是，现在所有这些项目的不确定性都降低了。整洁！

正如我们在看到的关于勘探开发的帖子，我们可以鼓励对这些稀疏地区的勘探。这样做之后，不确定性就会降低。这将导致该地区勘探的自然衰退。

最后的想法

在这篇文章中，我们详细阐述了如何使用一个统一的模型，以一种原则性的方式对所有三种类型的不确定性——数据、模型和测量——进行建模。

我们鼓励你思考如何在你的应用中使用不确定性！即使你不需要在你的预测中明确地模拟不确定性，你也可能从在训练过程中使用它中受益——如果你的模型能够更好地理解数据是如何产生的，以及不确定性如何影响游戏，它可能会有所改进。

这是与我们在今年 KDD 会议的一个研讨会上提交的论文相关的系列文章的第四篇: 深度密度网络和推荐系统中的不确定性 。

第一篇帖子可以在 这里找到 。
第二个帖子可以在这里找到。
第三个帖子可以在这里找到*。***

原载于engineering.taboola.com由我和 Inbar Naor 。

深度学习和神经网络中的不确定性？我没有那种感觉！

原文：https://towardsdatascience.com/uncertainty-in-deep-learning-and-neural-network-i-do-not-feel-that-way-f11ceca4341a?source=collection_archive---------1-----------------------

注意:这是 2014 年 6 月 5 日星期四的一篇旧博客文章

您可能知道，神经网络最近经常出现在新闻中，有许多成功的故事。

神经网络现在是最先进的算法，可以理解复杂的感官数据，如图像、视频、语音、音频、声音、音乐等。

神经网络最近更名为深度学习(DL)或深度神经网络。

2012 年，他们在一个行业标准图像数据集中超过任何其他算法 10%以上，成为新闻:

http://image-net.org/challenges/LSVRC/2012/results.html

他们在语音识别方面也有类似的提高，提高了 20%:

http://www . nytimes . com/2012/11/24/science/scientists-see-advances-in-deep-learning-a-part-of-artificial-intelligence . html？_r=0

和许多其他任务中。最近在熟悉面孔识别中达到人类表现的水平:

https://www.facebook.com/publications/546316888800776/

然而，行业和投资者都很谨慎。

他们经常看到新算法来来去去，几乎是年年如此。

他们说:“为什么一家初创公司要做深度学习或神经网络？当一个更好的算法出现并把你从平板电脑上抢走时，会发生什么？”

这是一个合理的怀疑，但是我确信我们不应该再为此担心了。

神经网络已经存在很多年了。

这有三个强有力的理由:

1.神经网络非常优越:

2012 年，深度神经网络算法被证明是理解复杂感官数据的最佳算法 10–20%，而不是每年 1–2%的典型改进。

这是复杂数据中算法性能的大差异。在我的职业生涯中，我从未见过如此大的进步。

想象一下，一名 100 米短跑运动员用 7.5 秒跑完，比其他人快了整整 2 秒，而以前的典型记录通常只比他快 0.1 秒。你不会感到惊讶吗？“几乎不真实！”

2.神经网络将在多项任务中达到人类水平的性能:

人脑是一个巨大的神经网络。深度学习提供了受生物神经系统(如人脑)启发的大型神经网络模型。

人脑是已知宇宙中复杂感官数据的最佳“处理器”。我们可以理解图像、视频、声音，就像今天没有电脑能理解的那样！

随着数据集和网络拓扑结构的改善，人脑模型，如深度学习中使用的人工神经网络，可以扩展到人类的表现。上面提到的脸书·迪普法斯就是一个例子。

随着我们加深对大脑神经拓扑的了解，并改进人工神经网络模型，我们可以在更多的任务中达到人类的表现。现在这种情况正在发生:每隔几个月，我就会有一个新的结果。

3.神经网络可以扩展:

我们在过去已经看到许多算法不能扩展到感官数据的复杂性。他们可以做得很好几年，然后他们在新一波“新”算法下消失了。虽然这已经发生了，但神经网络持续不断地进化，有时在聚光灯之外，持续了 60 多年。我们将这一进展归功于许多聪明的同事和研究人员。

但是将神经网络与其他技术区分开来的一个区别是，它们是一个非常可扩展的模型。他们理解数据的能力可以随着模型的大小以及可用于训练这些模型的数据而增长。通过添加神经元层、不同的连接和连接拓扑、空间和时间形式的更多输入数据，模型可以提供不断增强的能力，以理解它们接受训练的复杂数据和同类的新数据。

底线:

深度学习和神经网络将继续存在。至少 10 年，或者只要我们在理解原始感官数据方面达到人类的表现水平。

如果您想投资并推动技术的未来，这就是您想要的！

你为什么要相信我？“这只是你的看法！”，”“你到底是谁？"

我是教授、发明家、工程师和科学家。我希望我的工作能改变世界。因为我的研究成功，我见到了美国总统奥巴马。我教授大学水平的计算神经科学、微芯片设计、计算机架构、机器和深度学习等等。

我在神经形态系统的设计方面有 20 多年的经验。我在模拟微芯片、数字微芯片、计算机代码和理论中看到过神经网络。我见过许多人工神经系统的例子，不管是在硬件领域还是软件领域，都有成功的例子，也有失败的例子。我自己设计了许多系统，以第一人称测试代码和算法，而不仅仅是通过其他人的工作。

我的目标是用我的科技知识帮助人类。这就是现在的方法，用深度神经网络！

我不喜欢算法，我喜欢可行的和可扩展的。深度神经网络现在可以工作和扩展。

我见过很多事情，我有经验把我的一生花在对整个人类的重要目标上。如果我不是非常相信神经网络的力量和潜力，我不会在这个领域工作。

现在相信我或者让时间说服你，代价是失去一个大好机会。

在你们做出决定的同时，我和我的所有同事将每天继续推动技术的发展，打破阻碍当前计算机理解图像、视频、语音、音频和任何复杂感官数据的障碍。

这是我们的选择，我们的命运。

这是不可避免的。

欢迎评论！

发布于 2014 年 6 月 5 日，星期四

关于作者

我在硬件和软件方面都有将近 20 年的神经网络经验(一个罕见的组合)。在这里看关于我:传媒、网页、学者、 LinkedIn 等等…

揭示 Python 中树集合的结构

原文：https://towardsdatascience.com/uncover-the-structure-of-tree-ensembles-in-python-a01f72ea54a2?source=collection_archive---------6-----------------------

Photo by Ghost Presenter on Unsplash

集成方法将多个基本估计量结合起来，以产生更稳健的模型，更好地概括新数据。 Bagging 和 Boosting 是集成方法的两个主要类别，它们的区别在于它们组合来自基础估计量的预测的方式。

Bagging 方法独立地建立估计量，然后平均它们的预测值。通过在构建每个基础估计量的方式中引入随机性，他们旨在减少最终模型的方差。换句话说，减少过度拟合。

Boosting 方法在序列中建立基本估计量，其中每个后续估计量从其前一个估计量的错误中学习。与减少方差相反，这些方法的目标是减少所得估计量的偏差。

每一类都包含几个算法。在这里，我们将看看两个广泛应用的算法，每个类别一个；随机森林作为装袋的例子 Ada Boost 作为 boosting 方法的例子，用决策树作为基本估计器。我们将在分类的上下文中讨论这些方法，尽管这两种方法也在回归任务中使用。

这篇文章的目的是展示如何通过可视化的树来挖掘集合的几个潜在估计量。

随机森林

随机森林，顾名思义，是一种建立在决策树上的装袋方法。每棵树都在数据的引导样本上进行训练，并且可以选择使用原始输入特征的子集。这两个随机因素确保了每棵树都是不同的。如果我们假设每棵树都超过了部分数据，我们期望它们的平均值会减少这种影响。

控制随机森林结构的主要参数是估计器的数量( n_estimators )，即构建的决策树的总数和用于在每个节点选择分裂的输入属性的最大数量( max_features )。

一般来说，估计量越大，结果越好。然而，大量的估计器也导致长的训练时间。也很有可能在一定数量的估计量之后，精确度的增加将趋于平稳。人们应该在准确性和性能之间寻求平衡。交叉验证是一种可以用来调整这些参数的原则性方法。

一旦选择了 n_estimators= N ，就以上述方式构建了 N 个决策树，并且通过对这些预测进行平均来获得最终预测。为了深入了解每个单独的预测，我们可以将构建的每个树可视化。

在这篇文章中，我们展示了如何在 Jupyter 笔记本中绘制决策树。这里，我们将更进一步，看看如何绘制一个系综的所有 N 棵树。

下面是为 sklearn 葡萄酒数据集训练随机森林分类器的脚本。

from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_wine# load dataset
data = load_wine()# feature matrix
X = data.data# target vector
y = data.target# class labels
labels = data.feature_namesestimator = RandomForestClassifier().fit(X, y)

分类器对象有一个属性 estimators_ ，它是一个由 N 棵决策树组成的列表。这个列表的长度给出了树的数量。

print(“Number of trees “ + str(len(trees)))Number of trees 50

如果我们打印 trees 对象，我们将得到每个估计量的摘要。

display(estimator.estimators_)

Sample of estimators_

我们可以遍历列表中的每个元素，得到每棵树的节点数。

print("Number of nodes per tree is ")

i_tree = 0
for tree_in_forest in trees:
print(tree_in_forest.tree_.node_count)
i_tree += 1Number of nodes per tree is 
23
23
9
19
27
27
21
23
21
25

现在，如果我们迭代 trees 对象，我们可以使用 export_graphviz 函数来绘制每棵树。因为树的数量通常很大，所以在笔记本中画出每一棵树并不方便。相反，我们可以将每个文件保存在工作目录中的. dot 文件中。如果您还想将每个文件保存为. png 格式，请使用 check_call 功能。

from sklearn.tree import export_graphviz
from subprocess import check_callcnt = 1
for item in trees:
     export_graphviz(item, out_file=str(cnt)+’_tree.dot’,feature_names= labels, class_names=labels, rounded=True, precision=4, node_ids=True, proportion=True
, filled=True)

     check_call([‘dot’,’-Tpng’,str(cnt)+’_tree.dot’,’-o’,str(cnt)+’_tree.png’]) cnt += 1

一旦迭代完成，我们将在我们的目录中得到一个文件编号列表。

List of files in directory

下面是两种经过训练的树。

Two of the Decision Trees of the trained Random Forest model

我们可以看到，每棵树可以有不同的深度，以及不同的节点结构和分裂。这正是在不同的数据子集上构建每棵树，并基于特征子集进行分割的结果。在这一点上，我们应该提到，bagging 方法通常在复杂的底层模型(即深树)中工作得更好，它们减少了过拟合效应。

Ada 增强

与 bagging 相反，boosting 方法的原理是训练一系列“弱”学习器，例如深度小的决策树。在每次迭代中，通过为数据的每个实例分配权重来构建树。首先，给定 k 个训练样本，每个训练样本被赋予等于 1/k 的权重。在每次迭代中，没有被正确分类的样本得到更高的权重，迫使模型在这些情况下更好地训练。最后，通过加权多数投票将预测结合起来。

Ada Boost 的主要参数是 base_estimator 和n _ estimator。估计量的数量相当于随机森林所描述的参数。基本估计量是基础模型的模型类型。在 sklearn learn 中，默认的基础估计器是决策树桩(具有 max_depth = 1 的决策树)。

与 RandomForestClassifier 类似，AdaBoostClassifier 也有一个 estimators_ 属性。因此，我们可以训练一个 AdaBoost 分类器，并以上述方式绘制所有的树。

from sklearn.ensemble import AdaBoostClassifierestimator = AdaBoostClassifier().fit(X, y)

trees = estimator.estimators_

print("Number of trees " + str(len(trees)))Number of trees 50

sklearn 中 AdaBoost 的默认估计数是 50。使用与上面完全相同的循环，我们可以得到 50 棵决策树中每一棵的图像。

Three first Decision Trees of the trained AdaBoost model

有前三个决策树，每个在顶部节点有不同的分割。这一次，不同的分裂是由于每个样本在每次迭代中得到的不同权重。每棵树都专注于正确预测前一棵树未能正确分类的内容。

在本文中，我们看到了一种可以应用于 bagging 和 boosting 两个分类器家族的方法，以便可视化底层模型，这些模型的投票构成了我们模型的最终预测。通过这种可视化，我们展示了如何通过装袋中的随机化和 boosting 中的权重分配从相同的原始数据和输入要素构建 N 个不同的树。再一次，我发现这是一个实用的方法，可以更好地理解集合方法在幕后是如何工作的，并且在我们的项目中使用这种模型时，可以减少黑箱。

使用数据科学揭示 AirBnB 评论中的隐藏趋势

原文：https://towardsdatascience.com/uncovering-hidden-trends-in-airbnb-reviews-11eb924f2fec?source=collection_archive---------9-----------------------

欢迎来到词汇世界

在做情感挖掘的研究时，我熟悉了主观词汇的重要概念。词典的应用是情感分析的两种主要方法之一。它包括从文本中出现的单词或短语的语义方向计算情感。

R 中可用的词典:

qdap 的极性()函数:使用来自 hash _ 情操 _ 刘虎(IL @CHI 极性(+/-)词研究的 U)的词典

• NRC —根据 8 种情绪的单词，如“愤怒”或“喜悦”以及阳性/阴性
• 并 —标记为肯定或否定的词
• AFINN —得分从-5 到 5 的单词

省力原则 使有限的词库变得有用。

您可以根据自己的需要随时修改词典！

1.定义业务问题

这是我最喜欢的，也是任何项目成功的最重要的一步:问正确的问题。一些领域的理解或与领域专家的交流确实有助于定义一个合适的问题陈述。

你应该很清楚自己的数据，并且有充分的理由去挖掘情感，而不仅仅是因为这听起来很酷！；)

例如，通常在调查中，消费者被要求在一定范围内对产品进行评级。在这种情况下，一个有序的评级足以确定消费者对产品的情绪，这里的情绪分析就有点过了。如果你想** 知道消费者喜欢或不喜欢产品的什么， 使用开放式问题，并使用回答提取有意义的见解。**

在这个博客中，我们将找出哪些住房属性(例如，餐馆、地铁站附近、卫生、安全等。)根据总体客户评价带来良好的租赁体验。

2.识别文本来源

从任何网站获取顾客评论的流行方式之一是通过网络搜集。用 R 或者 Python 都可以。我会在我的下一篇博客中保留这个话题。目前，我选择了一个数据集，其中有 1000 条关于波士顿 AirBnB 租赁的用户评论。****

*# Upload dataset in R (available as .rds file)* 
> bos_reviews <- readRDS("bos_reviews.rds", refhook = NULL)

3.组织和清理文本

在这一步，我们将使用两种不同的词汇( Polarity 和 BING )来确定所收集的房屋评论的情感得分。

基于简单 Qdap 的极性评分

从进行情绪分析开始是一种合理的方法，因为它让您熟悉数据，并帮助您设定期望，以更好地解决业务问题。为此，来自 qdap 封装的极性功能非常有用。它允许我们将文本分为正面或负面。

*# Check out the boston reviews polarity overall polarity score* > bos_pol <- polarity(bos_reviews)  
> bos_pol all total.sentences total.words ave.polarity sd.polarity stan.mean.polarity all 1000 70481 0.902 0.502 1.799 *# Summary for all reviews* 
> summary(bos_pol$all$polarity) 
   Min. 1st Qu. Median  Mean  3rd Qu.  Max.   NA's 
-0.9712 0.6047  0.8921 0.9022 1.2063  3.7510   1 *# Kernel density plot of polarity score for all reviews* 
> ggplot(bos_pol$all, aes(x = polarity, y = ..density..)) + theme_gdocs() + geom_histogram(binwidth = 0.25, fill = "#bada55", colour = "grey60") + geom_density(size = 0.75)

The above graph shows that the median polarity score is greater than zero, i.e., the reviews tend to be positive. Notice that the reviews do not center on zero: this is known as grade inflation. There are two possible causes for this. First, social norms may lead respondents to be pleasant instead of neutral. The second reason could be **feature-based sentiment,where an author may write, “the bed was comfortable and nice, but the kitchen was dirty and gross” and the sentiment encompasses multiple “features” simultaneously, thereby skewing the average score.

TidyText 的必应词典

在这里，我们将直接从名为“comments”的 review 列创建 word data。

> library(tidytext) 
> library(tidyr) 
> library(dplyr) *# Use unnest_tokens to make text lowercase & tokenize reviews into single words.* 
> tidy_reviews <- bos_reviews %>% unnest_tokens(word, comments) *# Group by and mutate to capture original word order within each group of a corpus.* 
> tidy_reviews <- tidy_reviews %>% group_by(id) %>% mutate(original_word_order = seq_along(word)) *# Quick review* 
> tidy_reviews 
A tibble: 70,834 x 3 
Groups: id [1,000] 
id               word         original_word_order 
1 1               my                  1 
2 1            daughter               2 
3 1              and                  3 
4 1               i                   4 
5 1              had                  5 
6 1               a                   6 
7 1           wonderful               7 
8 1             stay                  8 
9 1             with                  9 
10 1            maura                 10 # ... with 70,824 more rows 
*# Load stopwords lexicon* 
> data("stop_words") *# Perform anti-join to remove stopwords* 
> tidy_reviews_without_stopwords <- tidy_reviews %>% anti_join(stop_words) *# Getting the correct lexicon* > bing <- get_sentiments(lexicon = "bing") *# Calculating polarity for each review* > pos_neg <- tidy_reviews_without_stopwords %>% inner_join(bing) %>% count(sentiment) %>% spread(sentiment, n, fill = 0) %>% mutate(polarity = positive - negative) *# Checking outcome* 
> summary(pos_neg) 
    id              negative         positive         polarity 
Min. : 1.0       Min. : 0.0000      Min. : 0.00     Min. :-11.000 
1st Qu.: 253.0   1st Qu.: 0.0000    1st Qu.: 3.00   1st Qu.: 2.000 Median : 498.0   Median : 0.0000    Median : 4.00   Median : 4.000 Mean : 500.4     Mean : 0.6139      Mean : 4.97     Mean : 4.356 
3rd Qu.: 748.0   3rd Qu.: 1.0000    3rd Qu.: 7.00   3rd Qu.: 6.000 Max. :1000.0     Max. :14.0000      Max. :28.00     Max. : 26.000 *# Kernel density plot of Tidy Sentiment score for all reviews* 
> ggplot(pos_neg, aes(x = polarity, y = ..density..)) + geom_histogram(binwidth = 0.25, fill = "#bada55", colour = "grey60") + geom_density(size = 0.75)

Based on the polarity distribution for both Qdap’s polarity score and TidyText’s BING, we can say that the comments are tending towards positive.

4.创建基于极性的语料库

在极性检查之后，我们需要创建一个大的文本集，用于下一步的特征提取。

a .根据步骤 2 中计算出的极性得分，将所有 1，000 条意见分为正面和负面意见。

*# Add polarity column to the reviews*
> bos_reviews_with_pol <- bos_reviews %>% mutate(polarity = bos_pol$all$polarity)

*# Subset positive comments based on polarity score*
> pos_comments <- bos_reviews_with_pol %>% filter(polarity > 0) %>% pull(comments)

*# Subset negative comments based on polarity score*
> neg_comments <- bos_reviews_with_pol %>% filter(polarity < 0) %>% pull(comments)

b .将正面和负面评论折叠成两个较大的文档。

*# Paste and collapse the positive comments* 
> pos_terms <- paste(pos_comments, collapse = " ") *# Paste and collapse the negative comments * 
> neg_terms <- paste(neg_comments, collapse = " ") *# Concatenate the positive and negative terms* 
> all_terms <- c(pos_terms, neg_terms)

c .创建词频逆文档频率(TFIDF)加权词频文档矩阵(TDM)。

这里，不是计算单词在语料库中的频率，而是对过度使用的术语惩罚 TDM 中的值，这有助于减少无信息的单词。

*# Pipe a VectorSource Corpus* 
> all_corpus <- all_terms %>% VectorSource() %>% VCorpus() *# Simple TFIDF TDM* 
> all_tdm <- TermDocumentMatrix(all_corpus, control = list( weighting = weightTfIdf, removePunctuation = TRUE, stopwords = stopwords(kind = "en"))) *# Examine the TDM * 
> all_tdm <> Non-/sparse entries: 4348/5582 Sparsity: 56% Maximal term length: 372 Weighting: term frequency - inverse document frequency (normalized) (tf-idf) *# Matrix* 
> all_tdm_m <- as.matrix(all_tdm) *# Column names* 
> colnames(all_tdm_m) <- c("positive", "negative")

5.提取特征

在这一步中，我们将从 TDM 中提取关键的住房特征，从而得出正面和负面的评价。

*# Top positive words* 
> order_by_pos <- order(all_tdm_m[, 1], decreasing = TRUE) *# Review top 10 positive words* 
> all_tdm_m[order_by_pos, ] %>% head(n = 10) DocsTerms       positive     negative 
walk           0.004565669       0 
definitely     0.004180255       0 
staying        0.003735547       0 
city           0.003290839       0 
wonderful      0.003112956       0 
restaurants    0.003053661       0 
highly         0.002964720       0 
station        0.002697895       0 
enjoyed        0.002431070       0 
subway         0.002401423       0 *# Top negative words* 
> order_by_neg <- order(all_tdm_m[, 2], decreasing = TRUE) *# Review top 10 negative words* 
> all_tdm_m[order_by_neg, ] %>% head(n = 10) DocsTerms       positive      negative 
condition           0        0.002162942 
demand              0        0.001441961 
disappointed        0        0.001441961 
dumpsters           0        0.001441961 
hygiene             0        0.001441961 
inform              0        0.001441961 
nasty               0        0.001441961 
safety              0        0.001441961 
shouldve            0        0.001441961 
sounds              0        0.001441961

6.分析特征

让我们比较一下通过 WordClouds 获得正面和负面评价的房屋特征。

a .对比云

> comparison.cloud(all_tdm_m, max.words = 20, colors = c("darkblue","darkred"))

b .缩放后的对比云

通过这种可视化，我们将在执行语料库子集之前，通过将评论分数调整回零，修复等级膨胀对租赁评论极性分数的影响。这意味着一些先前的正面评论可能会成为负面子部分的一部分，反之亦然，因为平均值变为零。

*# Scale/center & append* 
> bos_reviews$scaled_polarity <- scale(bos_pol$all$polarity) *# Subset positive comments* 
> pos_comments <- subset(bos_reviews$comments, bos_reviews$scaled_polarity > 0) *# Subset negative comments* 
> neg_comments <- subset(bos_reviews$comments, bos_reviews$scaled_polarity < 0) *# Paste and collapse the positive comments* 
> pos_terms <- paste(pos_comments, collapse = " ") *# Paste and collapse the negative comments* 
> neg_terms <- paste(neg_comments, collapse = " ") *# Organize* 
> all_terms<- c(pos_terms, neg_terms) *# VCorpus* 
> all_corpus <- VCorpus(VectorSource(all_terms)) *# TDM* 
> all_tdm <- TermDocumentMatrix( all_corpus, control = list( weighting = weightTfIdf, removePunctuation = TRUE, stopwords = stopwords(kind = "en"))) # Column names 
> all_tdm_m <- as.matrix(all_tdm) 
> colnames(all_tdm_m) <- c("positive", "negative") # Comparison cloud 
> comparison.cloud(all_tdm_m, max.words = 100, colors = c("darkblue", "darkred"))

除了上面的分析，我还想评估一个作者在写正面评论和负面评论时付出的努力之间的相关性。这是通过绘制正面和负面评论的字数来完成的。

*# Create effort* 
> effort <- tidy_reviews_without_stopwords %>% count(id) *# Inner join* 
> pos_neg_with_effort <- inner_join(pos_neg, effort) *# Review* 
> pos_neg_with_effort  
A tibble: 953 x 5 Groups: id [?] 
id      negative     positive      polarity     n 
1 1         0            4             4        26 
2 2         0            3             3        27 
3 3         0            3             3        16 
4 4         0            6             6        32 
5 5         0            2             2         8 
6 6         0            3             3        21 
7 7         0            5             5        18 
8 8         0            2             2        10 
9 9         0            4             4        12 
10 10       1           15            14        46 
*# ... with 943 more rows * *# Add pol* 
> pos_neg_pol <- pos_neg_with_effort %>% mutate(pol = ifelse(polarity >= 0, "Positive", "Negative")) *# Plot* 
> ggplot(pos_neg_pol, aes(polarity,n, color = pol)) + geom_point(alpha = 0.25) + geom_smooth (method = "lm", se = FALSE) + ggtitle("Relationship between word effort & polarity")

7.得出结论

不足为奇的是，顶级正面词汇包括:

• 步行
• 装备精良
• 饭店
• 地铁
• 站

相比之下，最负面的术语包括:****

• 自动过账
• 垃圾箱
• 肮脏的
• 卫生
• 安全
• 声音

同样，可以看出作者会花更多的精力来写一篇更强有力的正面或负面评论。这话多么真实啊！

我确信，有了更大的数据集，我们可以挖掘出比这个小案例研究更深刻的见解。

非常感谢您的阅读！

我写这篇博客的目的是与所有有志成为数据科学家的人分享情绪分析的基本概念，但我们不能就此止步！我想我已经准备好为我的作品集做一个更精细的情感挖掘项目了，:D，你呢？

请在下面的评论中分享你的想法/反馈。

也可以在 Linkedin 上和我联系。

继续编码。干杯！

(首发@www.datacritics.com)

揭开 Airbnb 高收入的秘密

原文：https://towardsdatascience.com/uncovering-the-secrets-to-higher-airbnb-revenues-6dbf178942af?source=collection_archive---------8-----------------------

使用数据分析和机器学习来揭示波士顿和西雅图 Airbnb 成功上市背后的秘密

介绍

Airbnb 是全球最受欢迎的短期租赁在线房源服务之一。虽然建立 Airbnb 业务相对容易，但在这一行取得成功可能很难。如果你正在考虑进入波士顿和西雅图的 Airbnb 业务，这篇文章就是为你而写的。

我们将探索 Airbnb 在这些城市是否确实是一项可行的业务，并应用数据分析和机器学习来确定策略，以帮助您获得超越竞争对手的优势。

将调查以下问题:

• Airbnb 主机的收入有多少？
• 出租什么类型的房产最好？
• 什么时候是最好的租赁时间？
• 哪些区域最适合出租？
• 为了吸引更多的注意，你应该在列表名称中写些什么？

我们还将分享一些额外的技巧，帮助你成为一名成功的 Airbnb 房东，敬请关注。

数据

为了回答这些问题，我们将使用 Kaggle 提供的 Airbnb 数据集来处理波士顿和 T2 的数据。这些数据集提供的信息包括两个城市的房源详情、客户评论和房源安排。

假设

虽然两个数据集都没有提供预订的详细信息，但我们可以根据他们在该时间段内收到的评论数量来估计每个酒店的预订数量。然后，我们可以用以下公式推断每项资产的收入:

评论数量 x 列表价格 x 最短停留时间

这是对收入的保守估计，因为酒店的预订量很可能会超过点评量。此外，客人还可能会停留超过规定的最低住宿天数。

事不宜迟，我们开始吧！

s

2015 年波士顿的平均主机收入为 7200 美元，而西雅图为 4700 美元

2015 年，波士顿 Airbnb 主机的平均估计收入为 7200 美元。在一年中有 90 多天在网上登记房产的活跃房东中，平均年收入增长到了 9000 美元左右。

虽然 2015 年波士顿 Airbnb 主机的平均收入相对较高，但收入差距普遍存在。50%的活跃主机收入低于 3，900 美元，而前四分之一的活跃主机平均收入超过 9，800 美元。

波士顿的顶级 Airbnb 主机在 2015 年获得了超过 371，000 美元的收入！事实上，4 个票房收入最高的主机在那一年获得了至少 10 万美元的收入。

在西雅图，2015 年 Airbnb 主机的平均收入估计为 4700 美元，而一个活跃的主机收入超过 4900 美元。

和波士顿的情况一样，西雅图也存在收入差距。50%的活跃主机收入不到 2，400 美元，而前 25%的活跃主机平均收入超过 5，800 美元。同时，西雅图的顶级主持人获得了超过 27 万美元的收入。

在波士顿，你应该租出整个公寓或房子，而在西雅图，能容纳 4 个人的公寓最好

在波士顿出租整个公寓或房子可能会带来不错的收入。预计整套公寓的年收入为 6100 美元，整栋房子的年收入为 6700 美元。

这不仅远高于波士顿 Airbnb 房源的平均收入(4600 美元)，公寓和房屋也是波士顿房源的最大组成部分。因此，对这类房产的需求相对健康。

虽然可能有其他类型的财产(床和早餐，阁楼等。)产生了更高的收入，它们在波士顿上市公司中所占的比例较小，因此更有可能服务于较小的利基市场。

Average annual revenues of Airbnb listings in Boston in 2015

Number of listings by property type in Boston in 2015

此外，能容纳更多客人的酒店也更有可能在波士顿创造更高的收入。事实上，容纳 4 位客人的酒店的平均收入几乎是容纳 3 位客人的酒店的两倍。2015 年，可容纳 6 名客人的房源收入最高。但是这些房源比较稀缺，所以这个细分市场可能不会很大。

Mean Revenues vs Number of Guests in Boston in 2015

列表的收入会有很大的不同，就像主机的收入一样。2015 年，波士顿 50%的房源收入低于 2300 美元，而前 25%的房源收入超过 5520 美元。

如果你正在西雅图寻找一个完美的 Airbnb 房源，那就看看能容纳 4 人的公寓吧。2015 年有 336 处此类房产上市，平均年收入为 4500 美元。

相比之下，2015 年西雅图 Airbnb 房源的平均收入为 3400 美元。

Average annual revenues of Airbnb listings in Seattle in 2015

Number of listings by property type in Seattle in 2015

出租整艘船估计每年可以获得 9000 美元的收入，远远超过其他任何财产。然而，这个数字应该谨慎对待，因为 2015 年只有两个这样的财产被列入名单。

如果你出租整栋房子或公寓，这是西雅图最常见的房源，你可以合理地预计分别获得 4500 美元和 4000 美元。

在西雅图，能容纳更多客人的酒店也在 2015 年创造了更高的收入。同样，理想的客人数量似乎是 4 个，因为这些酒店产生了相对较高的收入，同时仍然服务于相当大的市场。

Mean Revenues vs Number of Guests in Boston in 2015

有两间卧室的房源也获得了相对较高的收入，同时仍然迎合了一个大市场。拥有超过 2 间卧室的影响通常可以忽略不计。当我们考虑到超过 4 间卧室的房源的较小市场规模时，这一点尤其正确。

Mean Revenues vs Number of Bedrooms in Boston in 2015

收入差距在西雅图也确实存在。50%的房产在 2015 年收入低于 1800 美元，而前 25%的房产收入超过 4500 美元。

八月和九月是波士顿最好的租房时间。虽然八月是西雅图最好的月份

8 月和 9 月是波士顿 Airbnb 房产最好的月份。这几个月的收入最高也就不足为奇了，因为这段时间天气通常很好，游客可以欣赏波士顿令人惊叹的秋色。

在西雅图，八月是出租房产的最佳月份，而七月和九月也是有利可图的选择。

在这两个城市，总收入多年来一直大幅上升，这表明在可预见的未来，对 Airbnb 房产的需求可能会增长。

灯塔山和后湾是波士顿表现最好的社区，而第一山是西雅图最好的社区

在波士顿，Beacon Hill 在 2015 年创造了所有社区中最高的收入，平均每份房源约 7400 美元。Back Bay 是第二好的社区，总收入超过 6900 美元。

就可用房源总数而言，这两个社区都位列前五名。这是 Airbnb 认可的波士顿 25 个社区中的一个。

注意:在地图上，每个邻近区域都用一个圆圈表示，圆圈的颜色反映了邻近区域中某个列表的平均收入。每个圆圈的大小对应附近的房源数量，圆圈越大，房源越多。

This map depicts the average revenue in each neighborhood in Boston during 2015.

在西雅图的所有社区中，第一山的收入最高，2015 年平均每家上市公司的收入超过 5900 美元。然而，值得注意的是，与贝尔敦和百老汇等社区相比，该地区的房源数量明显较低。

中央商务区和史蒂文斯是 2015 年票房收入第二高的社区。2015 年，这两个社区的 Airbnb 房源收入约为 4500 美元。

This map depicts the average revenue in each neighborhood in Seattle during 2015.

在你的刊登名称中提及热门地点

潜在客户在寻找公寓时首先看到的往往是房源名称和房源图片。因此，你的上市名称吸引读者的注意力是至关重要的。

Most popular words used in the names for Boston listings ranked in the top 10% of revenue generated

上面显示的是收入排名前 10%的波士顿上市公司名称中最常用的词的词云。相比之下，下面的单词云描述了收入排名后 30%的列表中最常见的单词。

注意:单词在云中的大小与其在列表中出现的频率相对应，使用频率越高的单词出现得越大。

Most popular words used in the names for Boston listings ranked in the bottom 30% of revenue generated

通过比较，我们立即注意到，像 South End 、 Back Bay 和 Beacon Hill 这样的社区经常出现在高收入的列表中。另一方面，这些社区在低收入的列表中很少被提及。因此，如果你的房产位于上述社区附近，一定要在你的房源名称中突出显示。

单词 studio 在表现最好的列表中出现过多，而单词 room 在表现较差的列表中出现过多。在波士顿，出租工作室单元似乎比出租房间更有利可图，尽管人们必须记住，出租房间可能比工作室单元产生更低的运营成本。

有趣的是，虽然像漂亮、宽敞这样的词在这两种房源中都很常见，但顶级房源更有可能使用现代这个词来描述它们的房产，而收入较低的房源更倾向于使用舒适这个词。这可能是波士顿游客更喜欢现代装饰的一个标志。

下面显示的是收入排名前 10%的西雅图列表名称中最常用的词。

Most popular words used in the names for Seattle listings ranked in the top 10% of revenue generated

相比之下，收入排名在后 30%的列表中使用频率最高的词。

Most popular words used in the names for Seattle listings ranked in the bottom 30% of revenue generated

两者之间最明显的区别是，顶级上市公司的名字中经常有西雅图 T21 这个词，而收入较低的上市公司很少提到它。另一方面，与顶级房源相比，低收入房源更有可能使用房间*、舒适、现代等词语。*

私人、市中心、巴拉德和国会山也更频繁地出现在顶级列表中，这表明这些属性很受欢迎。巴拉德和国会山都是西雅图的街区，很可能这两个地方都非常受游客欢迎。

有趣的是，视图在任一类型的列表中都有很好的表现。大多数游客可能是因为西雅图的壮观景色而来到这里的。

与波士顿相反，工作室单元的吸引力较低，这表明在西雅图拥有工作室单元没有任何优势。

从这一点可以得出一个重要的结论，即地名在列表名称中非常重要。房产的位置可能是 Airbnb 客户最重要的考虑因素之一。如果您的酒店位于任何热门地点附近，请确保在您的列表名称中突出显示这些地点的名称。

另一个关键要点是中的单词 room。在这两个城市，房源名称几乎总是与较低的收入联系在一起。

如果到目前为止你喜欢这篇文章，这里有一些额外的见解可以帮助你的 Airbnb 之旅。

Airbnb 超级房东在波士顿和西雅图挣得更多。在这两个城市，被认可为 Airbnb 超级房东可能会带来更高的收入。成为一名超级房东的要求如下:获得 4.8+的综合评分，在 24 小时内回复至少 90%的预订请求，每年至少接待 10 次住宿，并尊重每一次预订。

**波士顿偏好温和或严格的取消政策。**在波士顿，具有适度或严格取消政策的酒店往往能获得更高的收入。2015 年，实行中度或严格取消政策的酒店的收入中值为 2600 美元。相比之下，采用灵活或超严格 30 取消政策的酒店的收入中位数为 1300 美元。

**在波士顿，顾客更喜欢物有所值的房产。**波士顿 Airbnb 的顾客主要关心的是让他们的钱花得值。因此，在波士顿，价值评估得分较高的酒店往往表现更好。

在西雅图，顾客更喜欢干净的酒店。在西雅图，清洁度评分较高的酒店往往会获得略高的收入。西雅图的 Airbnb 客户肯定对清洁有强烈的偏好，所以要注意这一点。

**更高的清洁费不会影响波士顿的收入。**事实上，清洁费较高的房源往往比波士顿的其他房源表现更好。因此，如果你需要的话，不要害怕要求更高的清洁费，特别是如果你的地方为需要清洁的客人提供了很多额外的补贴。

在整篇文章中，我们看到了许多帮助你建立完美 Airbnb 房源的技巧和策略。现在，我们将总结一下这篇文章的主要发现。

波士顿 Airbnb 主机的关键见解概述

• 2015 年，波士顿 Airbnb 的平均收入为 7200 美元
• 租一整栋公寓可能会带来稳定的收入
• 可容纳 4 位客人的酒店似乎是最佳选择
• 八月和九月是出租房产的最佳时间
• Beacon Hill 和 Back Bay 通常是建立 Airbnb 的最佳社区
• 在你的列表名称中提及热门地点，如南端、后湾和比肯山可能会吸引浏览者的注意
• 工作室单位在波士顿是首选。
• 作为 Airbnb 超级房东，你会赚得更多
• 具有适度或严格取消政策的酒店通常表现更好
• 顾客更喜欢物有所值的房产
• 更高的清洁费不会影响收入

西雅图 AIrbnb 房东的关键见解概述

• 2015 年，西雅图 Airbnb 的平均收入为 4700 美元
• 租一整栋公寓来接待 4 个客人可能会带来稳定的收入
• 有两间卧室的房产是最好的选择
• 八月是出租房产的最佳月份。七月和九月也是不错的选择
• 第一山是出租房产的最佳街区，其次是中央商务区和史蒂文斯
• 在你的列表名称中提到 private、downtown、Ballard 和 Capitol Hill 可能会吸引更多的兴趣
• 作为 Airbnb 超级房东，你会赚得更多
• 顾客更喜欢干净的房产

感谢您阅读这篇文章！我希望你喜欢它！

这个分析的代码可以在这里找到。

欠采样:不平衡数据的性能助推器

原文：https://towardsdatascience.com/under-sampling-a-performance-booster-on-imbalanced-data-a79ff1559fab?source=collection_archive---------11-----------------------

在某些情况下，用于开发机器学习/深度学习模型的数据集通常是不平衡的。在这里，不均衡是指阶级分布的高度不平等或不均衡。不平衡数据的一个例子如下(图 1):

Fig 1. Binary Imbalanced Data

这里，标签 0 包含 24，720 个实例，而标签 1 仅包含 7841 个实例。这是一个二进制(因为有 2 个标签，0 和 1)不平衡数据的例子。通过对多数类(标签 0)进行欠采样，并使其接近标签 1，可以在很大程度上减少这种不平衡。其中一个著名的欠采样算法是基于聚类质心的多数欠采样技术(CCMUT) 。除此之外，我在之前的文章《 基于扩展聚类质心的多数欠采样技术(E-CCMUT) 》中介绍了基于扩展聚类质心的多数欠采样技术(E-CCMUT) 。在这之后的下一篇文章中，我一定会讨论 E-CCMUT 对 CCMUT 的改进。至于现在，在本文中，我将展示一个在 UCI 成人数据集上的实验，并从统计上证明欠采样可以获得更好的结果，并在不平衡数据集中充当性能助推器。

实验

“从人口普查数据预测一个人的收入水平是否大于 50k 美元”。

数据集

来自 UCI(加州大学欧文分校)的成人数据集用于预测模型开发。数据集包含 48，842 个实例和 14 个属性/特征

数据预处理

1. 对分类特征进行标签编码(参见表 1)
2. 特征选择通过使用额外的树分类器训练整个数据集并使用每个特征的特征重要性分数来完成，特征种族和本国被丢弃。(参见表 1)
3. 对分类特征进行一键编码，其中假设二进制值为 0/1，特征的每个类别成为特征本身。

Table 1

数据不平衡消除

数据的不平衡性质如图 1 所示。它包含 24，720 个‘0’标记的(多数)实例和 7841 个‘1’标记的(少数)实例。使用基于聚类质心的多数欠采样技术(CCMUT)来消除这种数据不平衡，其中多数类(标签 0)欠采样 68%。图 2 显示了 68%欠采样后数据失衡的减少。

Fig 2. Reduction in Data Imbalance after 68% Under-sampling

洗牌和拆分

结果数据集包含 7911 个“0”标记的实例和 7841 个“1”标记的实例。整个数据集以一致的方式进行混洗，并且 80–20 分割(80%训练集和 20%验证集)。

学习算法

在训练集上使用梯度提升分类器作为学习算法。分类器通过网格搜索进行调整，以获得最佳的超参数集。

网格搜索后得到 200 个估计量和最大深度为 4 的最优超参数。图 3 显示了基于平均分数的模型的网格搜索调整的总结。

Fig 3. Grid-Search Summary on Mean Score

结果:

使用度量、训练准确度、验证准确度、召回率、精确度、F1 分数、受试者操作者特征曲线下面积(图 4 所示的 AUROC)和混淆矩阵(图 5 所示)来分析模型性能。

Fig 4. ROC Curve showing Area Under the Curve

Fig 5. Normalized Confusion Matrix

表 2 中列出了训练准确度、验证准确度、召回率、精确度和 F1 分数。

与最先进技术的对比

到目前为止， Chakrabarty 等人【1】名为“ 一种成年人普查收入水平预测的统计方法 ”的研究论文是最先进的模型。表 2 给出了与最先进水平的比较。

Table 2

结论

从上述演示实验的统计结果来看，很明显，如果所使用的数据中存在类别不平衡，欠采样可以证明是非常强大的性能助推器。

参考文献

1 Chakrabarty，Navoneel 和 Sanket Biswas。"成人人口普查收入水平预测的统计方法." arXiv 预印本 arXiv:1810.10076 (2018)。

在分析项目的掩护下

原文：https://towardsdatascience.com/under-the-hood-of-an-analytics-project-1cc2348a5411?source=collection_archive---------11-----------------------

Photo by Markus Spiske on Unsplash

新数据项目早期阶段的演练

几周前，我写了一篇文章深入 NHL 的详细拍摄，如何转化为篮板，以及这两个事件如何影响比赛的结果。

在你现在正在阅读的文章中，我想从不同的角度来看同样的分析。我希望它能帮助潜在的/新的数据科学家了解如何开始构建自己的项目，并让我的想法更加清晰。

找到正确的问题

找到正确的问题通常是开始一个新的数据科学项目的最困难的部分，尤其是当这个问题没有提供给你的时候。很难找到动力去完成一个没有真正目的的项目，花时间定义你在做什么是至关重要的。

我喜欢散步，思考数据集，用它可以实现什么，我可以回答什么样的问题。通过这个项目，我可以访问过去 4 年中每场 NHL 比赛的详细数据，我想建立一个预测比赛结果的系统。

下面 Vox 的视频总结了这样做的动机。NHL 的结果被认为很大程度上是运气的结果。在运气-技能连续体中，曲棍球被归类为最“随机”的运动之一。我有疑问，我想深入了解一下。

深入研究

随着我更多地思考如何解决这个问题，我意识到我想要建立的系统会有多复杂。一开始，我不知道哪些数据与获胜相关，更重要的是，似乎其他人也不知道。显然已经对游戏的各个方面进行了研究，但我找不到我想做的事情的完美起点。

为了解决这个问题，我会从更简单的问题开始，然后建立一个最终模型。我预计这个项目将花费数百个小时，随着时间的推移，可能会增加到数千个小时——但你需要从某个地方开始。我决定在一系列我称之为“深度潜水”的游戏中系统地移动游戏的各个部分。这些深入的研究将建立在我对该领域的整体理解上，但也会产生我可以在最终模型中使用的特性。

所以我建立了一个灵活的计划来一次解决这些问题。我不知道我会在每个部分花多长时间——这个选择可以让我决定是否在必要时进一步追求一个想法。我要挖掘的一些数据不可避免地会相当不直观，可能会鼓励更多的探索。

经过一些初步的探索性挖掘，我采用了以下策略:

逐一深入以下类别，在数据中寻找有意义的相关性

• 射击
• 惩罚
• 打
• 失误
• 守门
• 主客场优势

然后，我会把我发现的见解构建到预测系统中。

在我分析的早期，很明显这将是一项艰巨的任务。我全神贯注于拍摄统计数据，亲眼目睹了为什么许多统计学家把这么多事情归结于偶然。然而，我也发现了一些我以前不知道的有趣信息(也找不到任何其他信息)。

最重要的是，我开始对游戏的一个非常具体的部分有了感觉。这让我相信，可以建立许多可以预测整个季节的特征，但这些相同的统计数据充满了嘈杂的异常值。我一直怀疑 NHL 是一个非常基于动力的游戏，一支球队如何在长期的基础上行动是他们成功的预测，行为比进球或射门等个人数据更重要。这篇文章的一个重要观点可以在下面的三张图中得到解释。

首先，我们发现什么是反弹。

其次，我们查看出现的次数来衡量重要性。

最后，我们查看了过去 4 年中的所有团队，以了解这些信息如何预测结果。

我们的结论。

“从分析的数据来看，更高的篮板球率实际上并不意味着更高的胜率。事实上，较高的反弹率与较低的胜场数相关联！

我们还发现，篮板率越高，投篮次数越少，投篮次数越多，胜率越高。”

代码走查

为了更好地介绍这个过程，并让您了解我是如何实现这一目标的，我提供了一些感兴趣的人来浏览代码。首先，你可以在这里得到原始数据。我们不会使用所有的数据集，我们主要关注的是详细的数据。

我们的第一步是加载比赛数据，提取进球和射门，创建标识射手和守门员的列，并缩放 x 和 y 位置，以便我们可以在我在 Plotly 上制作的曲棍球图上显示我们的射门分析。

然后，我们编写一个函数，它接受 shooting_df 函数的输出，并添加一些我们需要的数据。我们将添加球队名称，构建数据集，以便我们可以分析主场/客场，而不是输赢。

现在，我们将构建将在最终分析中使用的数据集。我想确定什么是反弹，这样我就可以利用这些信息来确定好的拍摄位置。由于没有明确的定义，我需要自己分析。

我对数据集中的独特游戏进行循环，并按时间顺序对每个游戏进行排序。然后，我可以在数据集上逐个镜头地迭代，并构建镜头之间的时间、这些镜头的结果以及反弹的位置。然后，我们添加一些必要的列，允许我们以几种不同的方式切割数据进行分析，特别是添加一个“for”列，以便我们可以查看整个赛季的球队。

为了更好地理解什么是反弹，我们需要按时间步长汇总我们的反弹数据框架。与此同时，我为 Plotly 图表添加了几个文本列，我们将使用它们来更好地了解篮板的影响和得分率。

这让我们可以创建我们在上面看到的前两个图，让我们知道什么是反弹。

知道了 3 秒以内的投篮命中率会有大幅上升，我按照前一次投篮在那个时间段内的任何一次投篮对篮板进行了分类。它让我们很好地了解了反弹的整体影响。

和下面的图表。

虽然抢篮板的投篮只占所有投篮的 5%,但他们占所有进球的 15%以上。

我也想知道高质量的照片是否有某种模式。在溜冰场制作热图的代码很长——所以我不会全部嵌入这里，但你可以在这个链接找到它。

概括地说，我们经历了以下过程:

1. 我们创造了各种情节性的形状，产生了一个空的曲棍球场作为情节。X 和 Y 轴用于模拟竞技场的一半。
2. 我们创建了一组盒子，将半溜冰场分成 625 个大小相等的盒子(25 x 25)。
3. 我们从数据中选取一个子集，使其符合上一步中为盒子创建的 x-y 坐标。然后我们根据需要(射门、进球或进球率)给它上色
4. 我们在每个框的中心产生一个数据点来提供鼠标悬停信息。

结果如下(互动版此处)

为了更好地理解拍摄地点，我回顾了这个图的一些变化。没有什么非显而易见的东西跳出来，但它给出了一些创建一个功能的想法，该功能涉及到在一些进一步的分析中使用这些框来产生镜头质量度量。从像这样的噪声数据到预测特征可能涉及几个阶段。

为了更好地理解拍摄地点，我回顾了这个情节的一些变化。没有什么非显而易见的东西跳出来，但它给出了一些创建一个功能的想法，该功能涉及到在一些进一步的分析中使用这些框来产生镜头质量度量。从像这样的噪声数据到预测特征可以包括几个阶段。

然后，我们有一个相对较长的代码片段来生成我们在原始文章中看到的 Plotly 图表。

我们取三个 x-y 对。

1. 反弹率与获胜次数
2. 反弹率与投篮次数
3. 击球次数与获胜次数

我们在这里发现了一些非直觉的信息，这让我相信曲棍球的特征在一段时间内比一场比赛更相关。我们还发现了一些可能会引导我们找到另一组特征的东西。也许我们需要根据球队的类型和守门员的质量来调整射门次数或篮板比例？

仅仅是开始

这只是这种分析的开始。我们甚至还没有触及这个复杂游戏的表面，但是我们已经发现了一些潜在的有价值的特性，并且获得了一些领域知识。

我希望这篇文章对新的数据科学家有所帮助，让他们了解探索性数据分析有多重要，并正确看待项目设计。

一键外卖 —玩长游戏，找到错综复杂的细节，然后开始建模。您将最终得到一个好得多的模型，并获得无价的领域知识，在您前进的过程中帮助您。

最初发表于Jesse Moore . ca。

在神经网络前向传播——可怕的矩阵乘法的掩护下

原文：https://towardsdatascience.com/under-the-hood-of-neural-network-forward-propagation-the-dreaded-matrix-multiplication-a5360b33426?source=collection_archive---------0-----------------------

简介

这篇文章的动机是我正在构建的神经网络中的一个令人沮丧的错误，它最终迫使我进入引擎盖下，真正理解神经网络核心的线性代数。我发现我做得很好，只是确保我相乘的两个矩阵的内部维度匹配，当错误发生时，我会在这里转置一个矩阵，在那里转置一个矩阵，直到事情解决，但这掩盖了我并不真正理解矩阵乘法如何工作的每一步的事实。

我们将介绍使用前向传播来计算一个相当简单的神经网络的成本函数的每个步骤。哦，如果你想知道我的矩阵乘法无知导致的错误，那就是我把我的偏差单位(1 的向量)作为一列添加了，而它应该是一行。我这样做是因为在这一步之前，我并没有真正理解矩阵乘法的全部输出，所以没有意识到我必须做出改变。首先，我将解释神经网络正向传播中发生的高级背景，然后我们将更仔细地看一个具体的例子，用索引值和代码来保持事情的清晰。

因此，神经网络在模拟复杂关系方面是不可思议的。我们只讨论网络的前馈传播部分。现在，神经网络的输入单元可以是任何东西。例如，它们可以是代表一串手写数字的 20 像素乘 20 像素图像的灰度强度(在 0 和 1 之间)。在这种情况下，您将有 400 个输入单元。这里我们有 2 个输入单元，加上+1 个偏置单元(关于为什么要有偏置单元的精彩解释，请点击这里)。正向传播实质上是从一个示例(比如一个手写数字的图像)中提取每个输入，然后将输入值乘以单元/节点之间每个连接的权重(见图 5)，然后将所有连接的所有乘积加到正在计算激活的节点上，取总和(z)并通过 sigmoid 函数进行计算(见下文)。

Figure 1: Sigmoid Function

这样你就可以激活隐藏层的每一个单元。然后你做同样的事情来计算下一层，但是这次你使用隐藏层的激活作为“输入”值。你将所有的 a 激活(即隐藏层)单元乘以第二组权重θ2，将连接到单个最终输出单元的每个乘积求和，并将该乘积通过 sigmoid 函数，从而得到最终输出激活 a。g(z)是 sigmoid 函数，z 是 x 输入(或隐藏层中的激活)和权重θ(在图 5 的正常神经网络图中由单个箭头表示)的乘积。

Figure 2: Hypothesis Function, using the Sigmoid Function.

一旦你有了所有这些，你想计算网络的成本(图 4)。对于给定的示例，您的成本函数本质上是计算输出假设 h(x)和实际 y 值之间的成本/差异。因此，在我一直使用的例子中，y 是输入所代表的实际数字的值。如果通过网络有一个“4”馈送的图像，则 y 是值“4”。因为有多个输出单元，所以成本函数将输出 h(x)与列向量进行比较，其中第 4 行是 1，其余都是 0。这意味着表示“4”的输出单元输出为真，其余都为假。对于 1、2 或 n 的输出，请参见下文。

Figure 3: Our example data y values represented as logical TRUE/FALSE column vectors.

Figure 4: The Multi-Class Logistic Regression Cost Function

上面成本函数 J(theta)中的两个适马用于合计通过网络输入的每个示例(m)和每个输出类(K)的成本。现在，你可以通过单独进行每个计算来做到这一点，但事实证明，人类定义矩阵乘法的方式非常适合同时进行所有这些正向传播计算。我们在数值计算方面的朋友已经优化了矩阵乘法函数，这样神经网络就可以极其高效地输出假设。编写我们的代码，以便我们同时进行所有的计算，而不是对所有的输入示例进行 for 循环，这是一个称为向量化代码的过程。这在神经网络中非常重要，因为它们在计算上已经足够昂贵，我们不需要任何 for 循环来进一步降低我们的速度。

我们的网络示例

在我们的网络中，我们将有四个类，1、2、3、4，我们将完成这个计算的每一步。我们将假设网络已经被训练，并且我们已经通过反向传播训练了我们的θ参数/权重。这将是一个 3 层网络(有两个输入单元，2 个隐藏层单元和 4 个输出单元)。网络和参数(也称为权重)可以表示如下。

Figure 5: Our Neural Network, with indexed weights.

在我们走得更远之前，如果你不知道矩阵乘法是如何工作的，那就去看看可汗学院花 7 分钟，然后做一两个例子，确保你对它是如何工作的有直觉。在前进之前知道这一点是很重要的。

让我们从所有的数据开始。我们的 3 个示例数据和相应的 y 输出值。这些数据不代表任何东西，它们只是显示我们将要进行的计算的数字:

Figure 6: Our data.

当然，正如我提到的，由于有 4 个输出单元，我们的数据必须表示为三个示例输出的逻辑向量矩阵。我在 MATLAB 中工作，把我们的 y 向量变成一个逻辑向量矩阵:

yv=[1:4] == y;   %creating logical vectors of y values

Figure 7: Matrix of Example Output y data turned into logical vectors.

另外，注意我们的 X 数据没有足够的特性。在我们图 5 的神经网络中，当我们计算权重/参数和输入值的乘积时，我们有虚线偏置单元 x(0)。这意味着我们需要将偏差单位添加到数据中。这意味着我们在矩阵的开头添加了一列:

X = [ones(m,1),X];

Figure 8: Data with bias added. Bias represented by dotted-line unit/node in Neural Net Figure 5

数据 X 被定义为第一个输入层 a 的第一个激活值，所以如果你在代码中看到 a(第 3 行)，它只是指初始输入数据。网络中每个连接/箭头的权重或参数如下:

Figure 9: First set of weights/parameters for our neural network with indices that match those on the arrows of the Figure 5 Neural Network diagram.

下面是我们将用于计算物流成本函数的完整代码，我们已经处理了第 2 行和第 9 行，但我们将在代码的其余部分慢慢分解矩阵乘法和重要的矩阵操作:

1:  m = size(X, 1);
2:  X = [ones(m,1),X]; 
3:  a1 = X;
4:  z2 = Theta1*a1';
5:  a2 = sigmoid(z2);
6:  a2 = [ones(1,m);a2];
7:  z3 = Theta2*a2;
8:  a3 = sigmoid(z3);
9:  yv=[1:4] == y;
10: J = (1/m) * (sum(-yv’ .* log(a3) — ((1 — yv’) .* log(1 — a3))));
11: J = sum(J);

让我们执行正向传播的第一步，上面代码中的第 4 行。将每个示例的输入值乘以它们相应的权重。我总是想象输入值沿着我们网络中的箭头流动(图 5 ),被击中/乘以权重，然后在激活单元/节点等待其他箭头进行乘法。然后，特定单元的整个激活值首先由这些箭头的总和(输入 x 重量)组成，然后该总和通过 sigmoid 函数传递(参见上面的图 1)。

所以这里很容易犯你的第一个矩阵乘法错误。因为我们的偏置单位加到 X(这里也称为 a1)的数据是 3×3 矩阵，而θ1 是 2×3 矩阵。简单地将这两个矩阵相乘是很容易的，因为θ:2×3 和 X:3×3 的两个内部维度是相同的，所以 viola 应该正确工作，并给出我们的 2×3 合成矩阵？不对！

z2 = Theta1 * a1;      %WRONG! THIS DOESN'T GIVE US WHAT WE WANT

虽然运行这个计算将输出一个我们期望的和下一步需要的正确维数的矩阵，但是所有计算的值都将是错误的，因此从现在开始所有的计算都将是错误的。此外，由于不存在计算机错误，即使您注意到了，也很难解释为什么您的网络成本函数会计算错误的成本。记住，当你做矩阵乘法时，得到的矩阵的每个元素 ab 都是第一个矩阵的行 a 乘以第二个矩阵的列 b 的点积和。如果我们使用上面的代码来计算上面的 z，那么得到的矩阵中的第一个元素将由我们的第一行 Theta 的[0.1 0.3]相乘得到。0.5]有一整列偏置单位，[1.000；1.000;1.000]，对我们没用。这意味着我们需要转置示例输入数据的矩阵，以便矩阵将每个θ与每个输入正确相乘:

z2 = Theta1*a1';

其矩阵乘法如下:

Figure 10: The indexed symbolic representation of the matrix multiplication. The resultant elements in the columns each representing a single example, and the rows being the different activation units in the hidden layer. 2 hidden layers results in two values (or rows) per example.

然后，我们对上述 z 矩阵中的 6 个元素分别应用 sigmoid 函数:

a2 = sigmoid(z2);

对于三个示例中的每一个，这仅仅给出了两个隐藏单元的隐藏层激活值的 2×3 矩阵:

Figure 11: The activation values of the hidden units.

因为这是作为矩阵乘法完成的，所以我们能够一次性计算隐藏层的激活值，而不是在所有示例中使用 for 循环，这在处理较大的数据集时会变得非常昂贵。更不用说还需要反向传播。

现在我们在第二层中有了激活单元的值，这些值作为下一层也是最后一层，即输出层的输入。对于图 5 中第二层和第三层之间的每个箭头，该层具有一组新的权重/参数θ2，我们将做与上面相同的事情。将激活值(输入)乘以连接到每个激活节点的权重，分别对连接到每个激活节点的乘积求和，然后通过 sigmoid 函数对每个激活节点求和，得到最终输出。上述 a 作为我们的输入数据，我们的权重/参数如下:

Figure 12: Theta2 weights/parameters with indices. Each row represents a different output unit with the weights contributing to each output unit across each column.

我们想做以下计算:

z3 = Theta2*a2;

但在此之前，我们必须再次将偏差单位添加到我们的数据中，在这种情况下，隐藏层激活 a。如果您在图 5 中再次注意到，隐藏层中的虚线圆圈 a(0)，偏差单位仅在我们进行下一次计算时添加。因此，我们将它添加到上面图 11 所示的激活矩阵中。

这是我介绍我的 bug 的地方，这也是我写这篇文章的动机。为了向前传播激活值，我们将θ中的一行的每个元素与 a 中的一列的每个元素相乘，并且这些乘积的总和将给出结果 z 矩阵的单个元素。通常数据的组织方式是将偏差单位作为一列添加，但是如果你这样做了(我愚蠢地这样做了)，这将会给我们错误的结果。所以我们将偏差单位作为一行添加到。

a2 = [ones(1,m);a2];

Figure 13: Adding the bias row to the a² activations.

在我们运行矩阵乘法来计算 z 之前，请注意，在 z 之前，您必须转置输入数据 a，使其正确“排列”,矩阵乘法才能产生我们想要的计算结果。这里，我们的矩阵按照我们想要的方式排列，所以没有 a 矩阵的转置。这是另一个常见的错误，如果你不理解其核心的计算，这是很容易做到的(我过去对此非常内疚)。现在，我们可以在 4x3 和 3x3 矩阵上运行矩阵乘法，从而为 3 个示例中的每一个生成 4x3 输出假设矩阵:

z3 = Theta2*a2;

Figure 14: The indexed symbolic representation of the matrix multiplication. The resultant elements in the columns each representing a single example, and the rows being the different activation units of the output layer, with four output units. In a classification problem this would mean four classes/categories. Also notice the [m] superscript index on all the a’s in each element is the example number.

然后，我们对 z 矩阵中的 12 个元素逐一应用 sigmoid 函数:

a3 = sigmoid(z3);

这就为我们提供了每个输出单元/类的输出层激活的 4x3 矩阵(也称为假设):

Figure 15: The activation values for each of the output units of the network, for each example. If you were doing a for loop over all your examples, this would be a column vector rather than a matrix.

从这里开始，你只是在计算成本函数。唯一要注意的是，你必须转置 y 向量的矩阵，以确保你在成本函数中进行的元素操作与每个示例和输出单元正确对齐。

Figure 16: Transpose of the logical y vectors matrix.

然后，我们将它们放在一起计算成本函数:

Figure 4: The Multi-Class Logistic Regression Cost Function

J = (1/m) * (sum(-yv’ .* log(a3) — ((1 — yv’) .* log(1 — a3))));
J = sum(J);

这就给出了我们的成本，注意，所有类和所有例子的总和都是双倍的。这就是所有的人。矩阵乘法可以使代码非常简洁高效，不需要 for 循环来减慢速度，但是您必须知道矩阵乘法中发生了什么，以便您可以适当地调整矩阵，无论是乘法的顺序、必要时的转置，还是将偏差单位添加到矩阵的正确区域。一旦你把它分解了，掌握起来就更直观了，我强烈建议你自己慢慢地看一遍这个例子，如果你还是不确定，它总是归结到一些非常简单的基础上。

我希望这有助于理解向前传播所需的线性代数。此外，这是我的第一个帖子，也是我的第一个技术帖子，所以任何反馈，问题，评论等，都非常感谢。

在神经网络的保护下。第 1 部分:完全连接。

原文：https://towardsdatascience.com/under-the-hood-of-neural-networks-part-1-fully-connected-5223b7f78528?source=collection_archive---------0-----------------------

深度学习进展很快，快得令人难以置信。拥有如此大的 AI 开发人员社区的原因之一是我们有许多非常方便的库，如 TensorFlow、PyTorch、Caffe 等。正因为如此，通常实现一个神经网络不需要任何该领域的高深知识，这是非常酷的！然而，随着任务复杂性的增加，了解内部实际发生的事情会非常有用。这些知识可以帮助您选择激活函数、权重初始化、理解高级概念等等。所以在这组文章中，我将解释不同类型的神经网络的推理和训练过程背后的数学原理。

这篇文章我将致力于最基本类型的神经网络:全连接网络。尽管纯全连接网络是最简单的网络类型，但理解它们的工作原理是有用的，原因有二。首先，与其他类型的网络相比，它更容易理解后面的数学。第二，全连接层仍然存在于大多数模型中。

在这里，我将解释任何监督神经网络中的两个主要过程:全连接网络中的前向和后向传递。这篇文章的重点将放在称为反向传播的概念上，它成为现代人工智能的主力。

前进传球

前向传递基本上是一组将网络输入转换到输出空间的操作。在推理阶段，神经网络仅依赖于正向传递。让我们考虑一个具有两个隐藏层的简单神经网络，它试图将二进制数(这里是十进制 3)分类为偶数或奇数:

这里我们假设除了最后几层的神经元，每个神经元都使用 ReLU 激活函数(最后一层使用 softmax )。激活函数用于将非线性引入系统，这允许学习复杂的函数。让我们记下在第一个隐藏层中进行的计算:

神经元 1(顶部):

神经元 2(底部):

将它改写成矩阵形式，我们将得到:

现在，如果我们将输入表示为矩阵 I(在我们的情况下，它是一个向量，但是如果我们使用批量输入，我们将使它的大小为样本数乘以输入数)，神经元权重为 W，偏差为 B，我们将得到:

其可以被概括为全连接神经网络的任何层:

其中 i —是层数， F —是给定层的激活函数。将此公式应用于网络的每一层，我们将实现正向传递，并最终获得网络输出。您的结果应该如下所示:

偶数道次

如果我们做所有的计算，我们最终会得到一个输出，这个输出实际上是不正确的(因为 0.56 > 0.44 我们输出的是偶数作为结果)。知道了这一点，我们想更新神经元的权重和偏差，这样我们就能得到正确的结果。这正是反向传播发挥作用的地方。反向传播是一种计算关于每个网络变量(神经元权重和偏差)的误差梯度的算法。这些梯度随后用于优化算法，如梯度下降，相应地更新它们。权重和偏差更新的过程称为反向传递。

为了开始计算误差梯度，首先，我们必须计算误差(即损耗)本身。我们将使用标准分类损失—交叉熵。然而，损失函数可以是任何可微分的数学表达式。回归问题的标准选择是均方根误差(RMSE)。交叉熵损失如下所示:

其中 M 是类的数量， p 是网络输出的向量， y 是真实标签的向量。对于我们的情况，我们得到:

现在，为了找到每个变量的误差梯度，我们将集中使用链式法则:

因此，从最后一层开始，对损失相对于神经元权重进行偏导数，我们得到:

了解在 softmax 激活和交叉吸附丢失的情况下我们拥有的事实(你可以自己推导出来作为一个很好的练习):

现在我们可以找到最后一层的梯度为:

继续第 2 层:

第一层:

对偏差遵循相同的程序:

现在我们可以跟踪一个常见的模式，它可以概括为:

这是反向传播算法的矩阵方程。有了这些等式，我们就可以计算每个权重/偏差的误差梯度。为了减少误差，我们需要在与梯度相反的方向上更新我们的权重/偏差。这种思想用于梯度下降算法，定义如下:

其中 x 是任何可训练变量(W 或 B)， t 是当前时间步长(算法迭代)，而 α 是学习率。现在，设置 α = 0.1(您可以选择不同的，但请记住，小值假设较长的训练过程，而高值导致不稳定的训练过程)并使用上面的梯度计算公式，我们可以计算梯度下降算法的一次迭代。您应该获得以下重量更新:

应用此更改并执行向前传递:

我们可以看到，我们的网络性能有所提高，与上例相比，现在奇数输出的值有所提高。对不同的例子(或一批样本)多次运行梯度下降算法，最终将得到一个经过适当训练的神经网络。

摘要

在这篇文章中，我解释了全连接神经网络训练过程的主要部分:向前和向后传球。尽管给出的概念很简单，但对反向传播的理解是建立鲁棒神经模型的一个基本步骤。我希望你从这篇文章中获得的知识能帮助你在训练过程中避免陷阱！

如果你觉得这篇文章有用，别忘了鼓掌，敬请关注！在下一篇文章中，我将解释递归网络的数学原理。

请在下面的评论中留下你的反馈/想法/建议/修正！

感谢阅读！

在神经网络的保护下。第二部分:经常性。

原文：https://towardsdatascience.com/under-the-hood-of-neural-networks-part-2-recurrent-af091247ba78?source=collection_archive---------5-----------------------

在本系列的第 1 部分中，我们已经研究了前馈全连接网络的前向和后向通路。尽管前馈网络很普遍，并且在现实世界中有很多应用，但是它们有一个主要的局限性。前馈网络不能处理顺序数据。这意味着它们不能处理不同大小的输入，也不能存储以前状态的信息(内存)。因此，在本文中，我们将讨论允许克服命名限制的递归神经网络(RNNs)。

前进传球

从技术上讲，循环网络可以表示为用状态变量和循环回路扩展的前馈网络。因此，在数学上，RNNs 的输入序列的每个元素被处理如下:

其中 It 为时步 t (输入序列的第 t 个元素)的输入， st 为时步 t 的隐藏状态， yt 为时步 t 的输出， fs 和 fo 为各层的激活函数。从等式中我们可以看出，递归网络的状态基本上是隐含层的输出。网络的 r ecurrence 通过在时间步长 t 的计算中出现 t-1 项来解释。因此递归网络的每次计算都依赖于先前的状态和输入。

随着递归网络在各种现实世界问题中的应用，我们可以看到 RNN 架构的不同变体，这些变体不会显著改变背后的数学。这种应用和相应模型的例子可以是:(a)语言翻译，(b)视频分类，(c)图像字幕，(d)自动完成系统。

(a) RNN for translation

(b) RNN for video classification

(c ) RNN for image captioning

(d) RNN for the autocomplete system

由于情况(a)的训练过程的数学推导可以容易地应用于其余情况，我们将考虑一个序列遍历网络的简单例子。假设我们有一个数字序列(用二进制表示)1，3，5，在将它们逐个输入我们的网络后，我们希望得到 5，3，1 作为输出。首先让我们随机初始化变量:

**注:**这里为了计算简单，我们将状态大小设为 2，然而状态变量通常是高维变量。

由于输出端可以有多个 1，我们将使用 sigmoid 激活函数( fo )，而 fs 将使用 tanh 。

现在，已经初始化了变量，我们可以使用上面介绍的等式来计算网络的正向传递。结果我们会得到:

示意性地，我们的网络看起来像:

偶数道次

与前馈相比，递归网络的第一个不同之处在于，我们也可以将序列作为输出。因此，损耗表示为每个输出端的损耗之和(或它们的平均值)。因此:

其中θ可以由任何可训练变量表示。

这里我们将再次使用交叉衰减(在第 1 部分中介绍)。在这种情况下，我们向前传球的损失是 3.30 。在激活功能之前，损失相对于 o 的导数为:

由于 Wo 和 Bo 不依赖于之前的时间步，没有循环回路，我们将从它们开始推导:

继续处理其余变量:

注: tanh 激活函数的衍生物:

现在我们有了计算梯度和应用梯度下降算法的所有方程(在第 1 部分中讨论)。让我们从分别计算每个输出的梯度开始，我们将从时间步骤 4 的输出开始:

对时间步骤 5 和 6 的输出执行相同的计算，我们将得到:

有了所有需要的梯度，我们可以将总损失的最终梯度计算为每个单独损失的梯度之和:

在应用学习率为 0.5 的梯度下降算法后，我们将得到新的变量:

现在，更新的网络将导致以下正向传递:

新的总损失等于 1.36 。

总结

在本文中，我介绍了递归神经网络 (RNNs)，并推导了训练过程所需的基本方程。这种类型的网络对于序列处理任务特别有用。

尽管反向传递后的训练损失显著减少，但这种网络的训练过程仍然是棘手的。首先，应该增加状态的维度。更重要的是，经典(或香草)rnn 很难记住旧的状态。为了解决这个问题，存在许多解决方案。其中最著名的可能是:

1. 在状态之间添加剩余连接(使得每个状态不仅依赖于前一个状态，也依赖于 t-2 或 t-3 状态)
2. 使用长短期记忆( LSTM )细胞，这需要单独一篇文章来描述。

在下一部分中，我将描述卷积神经网络，它成为了现代深度学习和计算机视觉领域的重要组成部分。

如果你觉得这篇文章有用，别忘了鼓掌，关注我，看更多这样的帖子！

请在下面的评论中分享你对未来帖子的反馈和想法！

感谢阅读！

了解如何通过 doc2vec 将您的段落转换为 vector

原文：https://towardsdatascience.com/understand-how-to-transfer-your-paragraph-to-vector-by-doc2vec-1e225ccf102?source=collection_archive---------7-----------------------

“person holding camera lens” by Paul Skorupskas on Unsplash

在之前的故事中，提到的 word2vec 是 Mikolov 等人(2013)介绍的。Mikolov 和 Le 发表了句子/文档向量转换。这是嵌入技术的又一个突破，我们可以用向量来表示一个句子或文档。米科洛夫等人称之为“段落向量”。

看完这篇文章，你会明白:

• 段落向量设计
• 体系结构
• 履行
• 拿走

段落向量设计

doc2vec 的设计基于 word2vec。如果你不熟悉 word2vec(即 skip-gram 和 CBOW)，你可以看看这个的故事。Doc2vec 还使用无监督学习方法来学习文档表示。每个文档的文本(即单词)输入可以是多种多样的，而输出是固定长度的向量。

段落向量和单词向量被初始化。段落向量在所有文档中是唯一，而单词向量在所有文档中是共享的，从而可以从不同的文档中学习单词向量。

在训练阶段，单词向量将被训练，而段落将被丢弃。在预测阶段(即在线预测)，段落向量将被随机初始化，并通过词向量来计算。

体系结构

学习单词向量有两种算法。这两种方法都是受学习单词向量的启发，单词向量是 skip-gram 和连续词袋(CBOW)

分布式段落向量记忆模型(PV-DM)

段落向量和单词向量都是随机初始化的。每个段落向量被分配给单个文档，而单词向量在所有文档之间共享。平均或连接段落向量和单词向量，并传递到随机梯度下降，梯度通过反向传播获得。

Architecture of PV-DM (Mikolov et al., 2014)

这种方法类似于 word2vec 中的连续词包(CBOW)方法。

【分布式文字包版本段落矢量(PV-DBOW)

另一种方法走的是不同的路。它不是预测下一个单词，而是使用段落向量对文档中的整个单词进行分类。在训练过程中，对单词列表进行采样，然后形成分类器，对单词是否属于文档进行分类，从而学习单词向量。

Architecture of PV-DBOW (Mikolov et al., 2014)

这种方法类似于 word2vec 中的跳格法。

履行

首先，我们需要传递训练数据来构建词汇，并调用训练阶段来计算单词向量。

doc2vec_embs = Doc2VecEmbeddings()
x_train_tokens = doc2vec_embs.build_vocab(documents=x_train)
doc2vec_embs.train(x_train_tokens)

之后，我们可以通过提供训练数据和测试数据对其进行编码。

x_train_t = doc2vec_embs.encode(documents=x_train)
x_test_t = doc2vec_embs.encode(documents=x_test)

最后，我们可以将向量传递给分类器

from sklearn.linear_model import LogisticRegressionmodel = LogisticRegression(solver='newton-cg', max_iter=1000)
model.fit(x_train_t, y_train)y_pred = model.predict(x_test_t)from sklearn.metrics import accuracy_score
from sklearn.metrics import classification_reportprint('Accuracy:%.2f%%' % (accuracy_score(y_test, y_pred)*100))
print('Classification Report:')
print(classification_report(y_test, y_pred))

结果

Accuracy: 52.8%
Average Precision: 0.66
Average Recall: 0.53
Average f1: 0.5

拿走

要访问所有代码，你可以访问我的 github repo。

• 与 word2vec 不同，doc2vec 动态计算句子/文档向量。换句话说，在预测时间内得到矢量需要时间。
• 根据 Mikolov 等人的实验， PV-DM 始终优于 PV-DBOW 。
• 在 PV-DM 方法中，串联方式通常比求和/平均方式更好。

参考

米克洛夫·托马斯，来自英国。2014.句子和文档的分布式表示

gensim 中的 doc 2 vec

理解文本摘要并在 python 中创建自己的摘要器

原文：https://towardsdatascience.com/understand-text-summarization-and-create-your-own-summarizer-in-python-b26a9f09fc70?source=collection_archive---------1-----------------------

文本摘要介绍

我们都与使用文本摘要的应用程序进行交互。这些应用程序中有许多是针对发布每日新闻、娱乐、体育文章的平台的。在我们忙碌的时间表中，我们更喜欢在决定阅读整篇文章之前先阅读那些文章的摘要。阅读摘要有助于我们确定感兴趣的领域，给出故事的简要背景。

摘要可以被定义为在保留关键信息和整体含义的同时产生一个简洁流畅的摘要的任务。

冲击

摘要系统通常有额外的证据，它们可以用来指定文档中最重要的主题。例如，当总结博客时，博客帖子后面的讨论或评论是很好的信息来源，可以确定博客的哪些部分是重要的和有趣的。

在科学论文摘要中，有大量的信息，如引用的论文和会议信息，可以用来识别原始论文中的重要句子。

文本摘要的工作原理

通常有两种类型的摘要，抽象的和提取的摘要。

1. **抽象概括:**抽象方法基于语义理解选择单词，即使那些单词没有出现在源文档中。它旨在以新的方式生产重要的材料。他们使用先进的自然语言技术解释和检查文本，以便生成新的更短的文本，传达原始文本中最重要的信息。

它可以与人类阅读文本或博客文章，然后用自己的话总结的方式相关联。

输入文档→理解上下文→语义→创建自己的摘要。

**2。提取摘要:**提取方法试图通过选择保留最重要观点的单词子集来总结文章。

这种方法对句子的重要部分进行加权，并用其形成摘要。使用不同的算法和技术来定义句子的权重，并基于它们之间的重要性和相似性来进一步对它们进行排序。

输入文档→句子相似度→句子权重→选择等级较高的句子。

有限的研究可用于抽象概括，因为与提取方法相比，它需要对文本有更深的理解。

与自动抽象摘要相比，纯粹的提取摘要经常给出更好的结果。这是因为抽象摘要方法处理诸如语义表示、
推理和自然语言生成之类的问题，这比诸如句子提取之类的数据驱动方法相对困难。

有许多技术可以用来生成摘要。为了简单起见，我将使用一种 无监督学习 方法来寻找句子的相似性并对它们进行排序。这样做的一个好处是，在项目中使用它之前，您不需要训练和构建模型。

理解余弦相似性对于充分利用你将要看到的代码是有好处的。余弦相似度是内积空间的两个非零向量之间的相似度，度量它们之间角度的余弦。因为我们将把我们的句子表示为向量束，所以我们可以用它来寻找句子之间的相似性。它测量矢量之间角度的余弦值。如果句子相似，角度将为 0 。

到现在都好..？ 希望如此:)

接下来，下面是我们生成总结文本的代码流:-

输入文章→拆分成句子→去除停用词→建立相似度矩阵→基于矩阵生成排名→挑选前 N 个句子进行汇总。

让我们创建这些方法。

1.导入所有必需的库

from nltk.corpus import stopwords
from nltk.cluster.util import cosine_distance
import numpy as np
import networkx as nx

2.生成干净的句子

**def read_article(file_name):**
    file = open(file_name, "r")
    filedata = file.readlines()
    article = filedata[0].split(". ")
    sentences = [] for sentence in article:
     print(sentence)
     sentences.append(sentence.replace("[^a-zA-Z]", " ").split(" "))
     sentences.pop() 

    return sentences

3。相似性矩阵

这就是我们将使用余弦相似度来寻找句子间相似度的地方。

**def build_similarity_matrix(sentences, stop_words):**
    # Create an empty similarity matrix
    similarity_matrix = np.zeros((len(sentences), len(sentences)))

    for idx1 in range(len(sentences)):
        for idx2 in range(len(sentences)):
            if idx1 == idx2: #ignore if both are same sentences
                continue 
            similarity_matrix[idx1][idx2] = sentence_similarity(sentences[idx1], sentences[idx2], stop_words)return similarity_matrix

4.生成汇总方法

方法将继续调用所有其他帮助函数，以保持我们的摘要管道运行。确保看一下下面代码中的所有# Steps。

**def generate_summary(file_name, top_n=5):**
    stop_words = stopwords.words('english')
    summarize_text = [] **# Step 1 - Read text and tokenize**
    sentences =  read_article(file_name) **# Step 2 - Generate Similary Martix across sentences**
    sentence_similarity_martix = build_similarity_matrix(sentences, stop_words) **# Step 3 - Rank sentences in similarity martix**
    sentence_similarity_graph = nx.from_numpy_array(sentence_similarity_martix)
    scores = nx.pagerank(sentence_similarity_graph) **# Step 4 - Sort the rank and pick top sentences**
    ranked_sentence = sorted(((scores[i],s) for i,s in enumerate(sentences)), reverse=True)    
    print("Indexes of top ranked_sentence order are ", ranked_sentence)for i in range(top_n):
      summarize_text.append(" ".join(ranked_sentence[i][1])) **# Step 5 - Offcourse, output the summarize texr**
    print("Summarize Text: \n", ". ".join(summarize_text))

所有放在一起，这里是完整的代码。

让我们看看它的运行情况。

一篇名为 的文章的全文微软推出智能云中心，提升学生在人工智能&云技术 方面的技能

In an attempt to build an AI-ready workforce, Microsoft announced Intelligent Cloud Hub which has been launched to empower the next generation of students with AI-ready skills. Envisioned as a three-year collaborative program, Intelligent Cloud Hub will support around 100 institutions with AI infrastructure, course content and curriculum, developer support, development tools and give students access to cloud and AI services. As part of the program, the Redmond giant which wants to expand its reach and is planning to build a strong developer ecosystem in India with the program will set up the core AI infrastructure and IoT Hub for the selected campuses. The company will provide AI development tools and Azure AI services such as Microsoft Cognitive Services, Bot Services and Azure Machine Learning.According to Manish Prakash, Country General Manager-PS, Health and Education, Microsoft India, said, "With AI being the defining technology of our time, it is transforming lives and industry and the jobs of tomorrow will require a different skillset. This will require more collaborations and training and working with AI. That’s why it has become more critical than ever for educational institutions to integrate new cloud and AI technologies. The program is an attempt to ramp up the institutional set-up and build capabilities among the educators to educate the workforce of tomorrow." The program aims to build up the cognitive skills and in-depth understanding of developing intelligent cloud connected solutions for applications across industry. Earlier in April this year, the company announced Microsoft Professional Program In AI as a learning track open to the public. The program was developed to provide job ready skills to programmers who wanted to hone their skills in AI and data science with a series of online courses which featured hands-on labs and expert instructors as well. This program also included developer-focused AI school that provided a bunch of assets to help build AI skills.

(来源:analyticsindiamag.com)

而用2**行作为输入的概括文本是

*Envisioned as a three-year collaborative program, Intelligent Cloud Hub will support around 100 institutions with AI infrastructure, course content and curriculum, developer support, development tools and give students access to cloud and AI services. The company will provide AI development tools and Azure AI services such as Microsoft Cognitive Services, Bot Services and Azure Machine Learning. According to Manish Prakash, Country General Manager-PS, Health and Education, Microsoft India, said, "With AI being the defining technology of our time, it is transforming lives and industry and the jobs of tomorrow will require a different skillset.*

如你所见，它做得很好。您可以进一步定制它，以减少到数字到字符而不是行。

重要的是要理解我们已经使用了 textrank 作为对句子进行排序的方法。TextRank 不依赖于任何以前的训练数据，可以处理任何任意文本。TextRank 是 NLP 的一个通用的基于图的排序算法。

有许多先进的技术可用于文本摘要。如果你是新手，你可以从一篇名为文本摘要技术:简要调查的有趣的研究论文开始

自然语言生成技术现状调查:核心任务、应用和评估是一篇更加详细的研究论文，您可以浏览一下以获得更好的理解。

希望这已经给了你一个文本摘要的简要概述和总结文本的代码示例演示。你可以从上面的研究论文入手，获取解决这个问题的高级知识和方法。

*这里显示的代码在我的GitHub**上有。*可以下载玩玩。

你可以在 Medium 、 Twitter 和 LinkedIn 上关注我，有任何问题，请发邮件给我(praveend806 [at] gmail [dot] com)。

理解这 4 个高级概念，听起来像机器学习大师

原文：https://towardsdatascience.com/understand-these-4-advanced-concepts-to-sound-like-a-machine-learning-master-d32843840b52?source=collection_archive---------3-----------------------

这是我一年前写的关于机器学习的一些基本概念的文章的续篇。有时候续集比《终结者 2》或《卡恩之怒》更好，但除非你看过第一部，否则你无法欣赏它们。去读那个帖子然后回来。我会等…

机器学习中有许多概念，理解这些概念对于掌握知识非常重要。更重要的是，如果你要实现人工智能，销售人工智能，集成人工智能，或者写关于人工智能的文章，你可能想要温习这些核心的，但先进的概念，以便有一个良好的，强大的基础来开始。

看完这篇文章后，你的 M 机器 I 智慧 L 收入 Q uotient(或 MILQ )将会大幅增加。你准备好了吗？

精确度和召回率

什么是活基督的精确和回忆？！有时当你读到精确和回忆时，它们听起来完全一样；“精确是你正确的频率，回忆是你正确的频率” —例如。Welp，它们实际上是不同的，不幸的是，对于理解为什么机器学习模型对用例有效或无效是重要的。

这可能是我解释这种差异的第三种最佳方式:

比方说，你试图记住一些事情，比如你一生中见过多少把蓝色雨伞。回忆描述了你有多擅长每次看到蓝色雨伞就回忆起来，代价是也会误认一些紫色雨伞的记忆。假设你在生活中看到了 10 把蓝色的雨伞，你把这 10 把雨伞都记住了。但是，你也错误地记住了另外 5 次，事实上它们是紫色的伞(但是你记得它们是蓝色的)。你的回忆是 100%，因为你每次都记得。恭喜你这个怪人！

现在精度将描述你的记忆中有多少是正确的。在上面这个奇怪的例子中，15 次记忆中，只有 10 次是正确的。因此，你的精度约为 66%。

那么哪个更重要呢？这取决于你的用例。如果你正在使用计算机视觉或深度学习从痣的照片中识别癌症，那么尽可能减少你告诉病人他们没有癌症的次数(假阴性)，甚至冒着增加告诉人们他们没有癌症的可能性(假阳性)的风险。

关键是你不能两者兼得，总有的权衡。这取决于哪个对你的用例更重要；冒着得到一些假阳性的风险得到每一个真阳性？或者冒着得到更多假阴性的风险，确保尽可能多的结果是真阳性。

明白了吗？如果你仍然困惑，不要担心，它很复杂，很难记住。但是我要继续前进…好吗？

识别与检测

当你应用机器学习时，你会有一些非常酷的工具，比如人脸识别和商标检测*。还可以有人脸检测和 logo 识别。搞什么鬼。为什么？*

让我通过提供每种类型的一些例子来解释这个概念:

人脸识别-输入是一张人脸的图像，机器学习模型识别这个人，并向您返回这个人的名字。

人脸检测-输入是人脸图像，模型会返回一个包围它找到的人脸的边界框。它告诉你脸在哪里，但不告诉你是谁。

图像识别—输入是一幅图像，输出(可能)是描述该图像的多个标签，如雾天、汽车、单色、建筑、风景等。

对象检测—输入是特定图像(如徽标)和要在其上进行检测的一般图像，输出是图像中特定图像(或徽标)出现的每个位置周围的边界框。

这有助于解释差异吗？没有吗？太好了——我们势如破竹，继续前进…

分类

很多好的机器学习实现实际上都是分类器。一篇文章是假新闻还是真新闻，这是一片叶子、一片棕榈叶、一片枫叶还是毒橡树的图像，这句话是不是一个连续的句子，等等。

每堂课就像一个选择或者一个标签。你训练一个机器学习模型，把一些输入数据(比如一张照片或一篇新闻)放到一个类中。有些模型可以给你几个类作为结果，有些一次只能做一个类。

要知道的关键是，当你训练一个分类器时，你必须遵循一些基本规则，否则它不会很好地工作(像我的语法检查器)。

1. 你的训练数据必须 平衡 。这意味着你必须有和你的狗一样多的猫的照片。如果你尝试训练一个类不均匀的模型，自然会变得更偏向于实例较多的类。
2. 这个模型不会仅仅指出哪些例子是错误的。你的训练数据必须非常干净。如果你的猫文件夹里有一些狗的例子，那么你真的是在欺骗自己。去把那些照片移到狗文件夹里。

深度学习

深度学习听起来很牛逼吧？还有什么比常规学习更好的呢？我知道..深度学习。好吧，事实证明深度学习很棒，但它有一个问题。首先，让我试着解释一下什么是深度学习。

大多数深度学习模型都是基于人工神经网络的。神经网络本质上是一层又一层的节点，这些节点以某种该死的神奇方式相互连接。当你的输入层和输出层之间有超过 1 或 2 层时，你就有了一个很深的网络！真正酷的是，当你训练网络时，它以某种方式弄清楚如何组织自己来识别人脸(例如)。它可能会将第一层分配给像素分组，第二层分配给边缘检测，第三层分配给鼻子理解，等等……但它会自己找出答案。太神奇了。

但这并不是一切。一个安全的经验法则是，当你听到深度学习时，它意味着 GPU。而 GPU 又很贵。所以你真的需要考虑你的用例。例如，有一个很棒的人脸检测器，而没有使用深度学习。这是一个计算机视觉过滤器，有大约 97%的准确率。这种人脸检测还有深度学习版。精确度逐渐提高，但这是以巨大的性能成本为代价的。你需要 GPU！而计算机视觉版本可以在单个 CPU 上超快运行。

所以，这又是一个权衡。

好了，你的机器学习硕士课程到此结束。

再见

理解这 5 个基本概念，让自己听起来像机器学习专家

原文：https://towardsdatascience.com/understand-these-5-basic-concepts-to-sound-like-a-machine-learning-expert-6221ec0fe960?source=collection_archive---------0-----------------------

https://cdn2.hubspot.net/hub/395829/file-2619018693-jpg/TheEvolutionofForecasting-03-15ENJPG.jpg

亚伦·爱戴是 机器盒子 的联合创始人——这是一家机器学习初创公司，旨在让用机器学习来建造东西变得容易。

大多数人似乎都对机器学习感到有点害怕或困惑。这是什么？它要去哪里？现在能给我一些钱吗？

所有有效的问题。事实是，你已经训练机器学习模型多年了，可能还没有意识到这一点。你用 iPhone 还是苹果照片？或者脸书怎么样？你知道它是如何向你展示一组面孔并让你识别它们的吗？嗯，通过标记这些照片，你正在训练一个面部识别模型来识别新面孔。恭喜你，你现在可以说你有训练机器学习模型的经验了！但在此之前，请阅读这些机器学习基础知识，这样你就可以准确地回答任何后续问题。

1)机器学习的好处是可以预测

如果你只是在图片中标记你朋友的脸，你就不是在使用机器学习模型。如果你上传一张新照片，突然它告诉你每个人是谁，那么你正在用机器学习气体做饭。机器学习的全部意义在于根据模式和其他训练它的因素来预测事物。它可以是任何东西；基于邮政编码和卧室数量的房价，基于一年中的时间和天气的航班延误可能性，图片中物体或人物的标记等。

2)机器学习需要训练

你必须告诉机器学习模型它试图预测什么。想想人类的孩子是如何学习的。他们第一次看到香蕉时，不知道那是什么。然后你告诉他们这是一根香蕉。下一次他们看到一个(不是你训练他们吃的那个，因为你已经吃过了)，他们会认出那是一个香蕉。机器学习以类似的方式工作。你给它看尽可能多的香蕉图片，告诉它这是一只香蕉，然后用一只没有被训练过的香蕉图片来测试它。这有点过于简化了，因为我省略了你必须告诉它什么不是香蕉的部分，并向它展示不同种类的香蕉，不同的颜色，不同视角和角度的图片等等。

3) 80%的准确率被认为是成功的

在技术上，我们还没有达到机器学习平台在识别图片中的香蕉时达到 100%准确率的地步。但是没关系。事实证明，人类也不是 100%准确。行业内的潜规则是，80%准确率的模型就是成功的。如果你想一想在你的收藏中正确识别 800，000 张图片是多么有用，尽管可能没有正确识别 200，000 张图片，你仍然节省了自己 80%的时间。从价值的角度来看，这是巨大的。如果我能挥动魔杖，让你的生产率提高那么多，你会给我很多钱。嗯，事实证明我可以，使用机器学习，所以请寄支票或现金。

2018 年更新:80%法则现在更像 90%法则了。

4)机器学习不同于人工智能、深度学习或神经网络

人们倾向于随便使用这些术语。要想听起来像专家，就要学会区别。

AI——人工智能只是指在完成特定任务方面与人类一样好(或更好)的计算机。它也可能意味着一个可以根据大量输入做出决定的机器人，就像终结者或 C3PO 一样。这是一个非常宽泛的术语，不是很有用。

机器学习是一种实现人工智能的方法。这意味着根据分析数据集的训练对某件事做出预测。有许多不同的方式，一个 ML 平台可以实现训练集来预测事情。

NL-神经网络是机器学习模型可以预测事物的方式之一。神经网络的工作有点像你的大脑，通过大量的训练来调整自己，以理解香蕉应该是什么样子的。你创建了一层层的节点，这些节点变得非常深。

5)在人工智能拥有自我意识之前，我们还有一段路要走

( https://xkcd.com/1319/))

我现在还不担心机器人会接管地球。主要是因为如果你曾经建立过一个机器学习模型，你就会知道它有多依赖你这个人来告诉它该做什么。即使你给它明确的指示，它通常也会出错。你必须对这些系统如此明确，以至于它突然变得有知觉的可能性微乎其微。即使是一个简单的网页，显示一个带有单词的框，也需要你准确地告诉它这个框出现在哪里，它是什么形状，它是什么颜色，如何在不同的浏览器上工作，如何在不同的设备上正确显示等等。等等。等等。

即使是非常深的神经网络接管世界，将我们变成电池，也有很多障碍，主要是因为没有人告诉它这样做(希望如此)。

用交互代码理解 Numpy 和 Tensorflow 中的 2D 展开卷积运算

原文：https://towardsdatascience.com/understanding-2d-dilated-convolution-operation-with-examples-in-numpy-and-tensorflow-with-d376b3972b25?source=collection_archive---------1-----------------------

Image from Pixabay

所以从这篇论文来看。用膨胀卷积进行多尺度上下文聚合，我被介绍到膨胀卷积运算。而且说实话只是用修改过的核，准确的说是更宽的核进行卷积运算。然而，为了充分理解一些事情，我需要实施它，因此有了这个帖子。

卷积 vs 扩张卷积(理论)

Image from paper

红线→ “熟悉的”离散卷积(在我们的例子中是正常的 2D 卷积)运算和扩张卷积之间的关系

我们熟悉的离散卷积就是 1-膨胀卷积 。因此，仅仅从这个陈述中，我们已经可以看出，当 1 的值增加到 2 时，这不是我们都喜欢的“熟悉的”卷积运算。而这一点，可以通过图片看得很清楚。

蓝色书写→ 膨胀因子为 1、2、4。(或 1-扩张卷积、2-扩张卷积和 4-扩张卷积)

那么这些扩张因子是什么呢？这可以用另一个图像来解释。(其实是同一个图像 lol)

蓝色数字 →应用于内核的膨胀因子

所以上图并不是膨胀卷积的最佳表现，但你可以大致了解这个膨胀因子是什么。并且随着膨胀因子的增加，原始核元素之间的空间变得越来越宽。现在让我们来看例子。

实验设置

红框 →原矩阵
蓝框 →我们要用的内核

因此，我们将使用蓝框核对红框矩阵执行多重卷积运算。但是，有三点需要注意。

1. 在 Tensorflow 中有两种方法来执行扩张卷积，或者通过基本的 tf.nn.conv2d() (通过设置扩张的)或者通过 tf.nn.atrous_conv2d()
2. 然而，似乎这两个操作都没有翻转内核。所以他们正在执行互相关(如果我错了请纠正我)，所以我们将手动翻转内核，如下所示。(红线)

3.如上所述，所有的 Tensorflow 操作将使用原始(3*3)内核，同时改变膨胀因子，而对于 Numpy，我们将为每个膨胀率生成特定内核。

例 1-扩张因子 1

我们已经知道，如果我们将膨胀因子设置为 1，它就像我们学会的卷积运算一样。所以这个例子没有什么特别的。现在让我们看一下代码。

红线 →注意我们正在对 Numpy
进行“熟悉的”卷积运算，黄线 →张量流的膨胀因子

示例 2 -扩张因子 2

红框 →为 Numpy 生成膨胀因子为 2 的内核

现在，由于膨胀因子已经增加到 2，我们将为 Numpy 生成一个新内核。

红线 →注意我们正在对 Numpy
黄线 →张量流的膨胀因子进行“熟悉的”卷积运算

示例 3 —扩张因子 3

红框 →为 Numpy 生成膨胀系数为 3 的内核

现在，由于膨胀因子已经增加到 3，我们将为 Numpy 生成一个新内核。

红线 →注意我们正在对 Numpy
进行“熟悉的”卷积运算，黄线 →张量流的膨胀因子

例 4—扩张因子 4

红框 →为 Numpy 生成膨胀系数为 4 的内核

现在，由于膨胀因子已经增加到 4，我们将为 Numpy 生成一个新内核。

红线 →注意我们正在对 Numpy
黄线 →张量流的膨胀因子进行“熟悉的”卷积运算

交互代码

我为了交互代码搬到了 Google Colab！所以你需要一个谷歌帐户来查看代码，你也不能在谷歌实验室运行只读脚本，所以在你的操场上做一个副本。最后，我永远不会请求允许访问你在 Google Drive 上的文件，仅供参考。编码快乐！

注意安装在 Google Collab 上的 Tensorflow 版本似乎不支持膨胀因子大于 2 的膨胀卷积，(仅适用于 tf.nn.conv2d())它会给出以下错误。所以我已经把 tf.nn.cond2d()注释掉了。

要访问代码，请点击此处。

最后的话

一个惊人的事实是:对扩张卷积运算进行反向传播只是转置卷积运算。

如果发现任何错误，请发电子邮件到 jae.duk.seo@gmail.com 给我，如果你想看我所有写作的列表，请点击这里查看我的网站。

同时，在我的推特这里关注我，访问我的网站，或者我的 Youtube 频道了解更多内容。如果你感兴趣，我还在这里做了解耦神经网络的比较。

参考

1. 膨胀卷积和克罗内克因子卷积。(2016).推论。检索于 2018 年 3 月 12 日，来自http://www . inference . VC/expanded-convolutions-and-kronecker-factorisation/
2. 卷积运算教程—no 1 . 0 . 0 文档。(2018).Deeplearning.net。检索于 2018 年 3 月 12 日，来自http://deep learning . net/software/the ano/tutorial/conv _ 算术. html
3. tf.nn.atrous_conv2d | TensorFlow。(2018).张量流。检索于 2018 年 3 月 12 日，来自https://www . tensor flow . org/API _ docs/python/TF/nn/atrous _ conv 2d
4. SciPy . signal . convolved 2d—SciPy v 1 . 0 . 0 参考指南。(2018).Docs.scipy.org。检索于 2018 年 3 月 12 日，来自https://docs . scipy . org/doc/scipy/reference/generated/scipy . signal . convolved . html
5. 数组，I. (2018)。NumPy 数组的就地类型转换。Stackoverflow.com。检索于 2018 年 3 月 12 日，来自https://stack overflow . com/questions/4389517/in-place-type-conversion-of-a-numpy-array
6. TF . nn . conv 2d _ back prop _ filter | tensor flow。(2018).张量流。检索于 2018 年 3 月 12 日，来自https://www . tensor flow . org/API _ docs/python/TF/nn/conv2d _ back prop _ filter
7. tf.nn.conv2d | TensorFlow。(2018).张量流。检索于 2018 年 3 月 12 日，来自https://www.tensorflow.org/api_docs/python/tf/nn/conv2d
8. “扩张卷积和卷积+步幅有什么区别？——Quora”。2018.Quora.Com。2018 年 3 月 12 日访问。https://www . quora . com/What-is-difference-of-expanded-convolution-and-convolution+stride。
9. 于，冯，科尔敦，伏(2015)。基于扩张卷积的多尺度上下文聚合。 arXiv 预印本 arXiv:1511.07122 。
10. 理解多层 CNN 转置卷积的反向传播。(2018).中等。检索于 2018 年 3 月 12 日，来自https://medium . com/swlh/only-numpy-understanding-back-propagation-for-transpose-convolution-in-multi-layer-CNN-with-c0a 07d 191981

理解黑盒

原文：https://towardsdatascience.com/understanding-a-black-box-896df6b82c6e?source=collection_archive---------7-----------------------

模型可解释性方法的概述…以及为什么它很重要。

在我们深入研究一些流行且相当强大的方法来打开黑盒机器学习模型(如深度学习模型)之前，让我们首先明确一下为什么它如此重要。

你看，有许多领域将受益于可理解的模型，如自动驾驶汽车，或广告定位，甚至有更多的领域需要这种可解释性，如信誉分配，银行，医疗保健，人力资源。能够审计这些关键领域的模型是非常重要的。

理解一个模型的最重要的特征让我们深入了解它的内部工作，并给出改进它的性能和消除偏差的方向。

除此之外，有时它有助于调试模型(经常发生)。然而，与预测一起提供解释的最重要的原因是，可解释的 ML 模型对于获得最终用户的信任是必要的(以医疗应用为例)。

我希望现在你也相信可理解的机器学习是非常重要的，所以让我们深入到具体的例子中来解决这个问题。

简单方法

人们能想到的最简单的方法是稍微改变输入数据，以观察底层黑盒是如何反应的。对于视觉数据，使用部分遮挡的图像是最简单的方法。对于文本——替换单词，对于数字/分类数据——改变变量。就这么简单！

这种方法的最大好处是——它是模型不可知的，您甚至可以检查其他人的模型，而无需直接访问它。

即使听起来很容易，好处也是巨大的。我多次使用这种方法来调试机器学习即服务解决方案和在我自己的机器上训练的神经网络，发现训练的模型选择不相关的特征来决定图像的类别，从而节省了工作时间。真正的 80/20 法则在起作用。

GradCAM

梯度加权类激活图——一种更高级更专业的方法。这种方法的限制是您需要访问模型的内部，并且它应该可以处理图像。为了让您对该方法有一个简单的直觉，给定一个数据样本(图像)，它将输出图像区域的热图，其中神经网络具有最多和最大的激活，因此图像中的特征与该类的相关性最大。

从本质上讲，与之前的模型相比，您对该模型的重要特性有了更细粒度的理解。

这里是 GradCAM 可解释性方法的一个很好的演示。
要了解 GradCAM 如何工作，请查看“Grad-CAM:通过基于梯度的定位从深度网络进行可视化解释”的论文。

石灰

也许你听说过这个。如果没有，首先看看这个简短的介绍。

2016 年发表《我为什么要相信你？:解释任何分类器的预测”的论文，该论文介绍了 LIME —局部可解释的模型不可知解释。让我们从名字中推导出它的功能！

局部可解释性*——*你要知道机器学习模型的复杂度越高，模型的可解释性越差。也就是说，逻辑回归和决策树比随机森林和神经网络更容易解释。LIME 方法的假设是，像随机森林或神经网络这样的非线性复杂模型可以是线性的，并且在局部是简单的，即在整个决策边界的小块上。回想一下，我们说过简单的模型是可以解释的。

模型无关 — 这部分比较容易。LIME 对被解释的模型没有任何假设。

关于 LIME 最好的事情是它也可以作为 PyPI 包使用。你已经准备好出发了！要了解更多信息，这里是他们的 GitHub repo 基准和一些教程笔记本，这里是他们论文的链接。仅供参考，LIME 也被 Fast Forward Labs(现在是 Cloudera 的一部分)用于演示模型可解释性的重要性。

SHAP

SHapley 附加解释 —一种理解黑盒模型的最新解决方案。在某种程度上，它非常类似于石灰。两者都是强大的统一解决方案，与模型无关，并且相对容易上手。

但是 SHAP 的特别之处在于它内部使用石灰。事实上，SHAP 背后有太多的可解释模型，它选择最适合手头问题的模型，用正确的工具给你所需的解释。

此外，如果我们分解这个解决方案的能力，我们实际上发现，SHAP 用 Shapley 值解释了任何机器学习模型的输出。这意味着 SHAP 为每个预测的每个特征分配一个值(即特征属性)；该值越高，该特征对特定预测的贡献就越大。这也意味着这些值的总和应该接近原始模型预测。

检查他们的 GitHub repo ，就像 LIME 一样，他们有一些教程，也可以通过 pip 安装 SHAP。此外，要了解更多细节，请查看他们的压印线预打印纸。

最终注释

机器学习模型的可解释性和可解释性是人工智能社区的一个热门话题，具有巨大的影响。为了让人工智能产品和服务进入新的高度监管的市场，必须了解这些新算法是如何做出决策的。

此外，知道机器学习模型的原因在调试它，甚至改进它方面提供了突出的优势。

在设计深度学习/机器学习系统时，最好考虑到可解释性，这样总是很容易检查模型，并在关键情况下抑制其决策。

如果你已经做到了，谢谢你！我鼓励你在这个新领域进行自己的研究，并在评论区与我们分享你的发现。

另外，如果你喜欢这篇文章，别忘了鼓掌😏或者关注我，获取更多关于机器学习和深度学习的各种主题的文章。

P.S .抱歉，这次没有 Colab 笔记本，因为已经有很多关于这个主题的非常好的教程让你开始。

通过食物理解机器学习的工作流程

原文：https://towardsdatascience.com/understanding-a-machine-learning-workflow-through-food-690ddad7803?source=collection_archive---------18-----------------------

Photo by Cel Lisboa on Unsplash

穿越美食？！

是的，没错，通过美食！:-)

想象一下，你点了一份披萨，过了一会儿，那份好吃的、热的和美味的披萨就送到了你家。

你有没有想过让这样一个比萨饼送到你家背后的工作流程？我的意思是，完整的工作流程，从播种番茄种子到骑自行车的人在你家门口嗡嗡作响！事实证明，与机器学习工作流程并无太大不同。****

真的！我们去看看吧！

这篇文章的灵感来自于谷歌首席决策科学家 Cassie Kozyrkov 在柏林举行的 Data Natives 会议上的一次演讲。

Photo by SwapnIl Dwivedi on Unsplash

1.播种

农民播下种子，这些种子会成长为我们比萨饼的配料，就像西红柿一样。

这相当于数据生成过程**，可以是用户动作，例如触发传感器的运动、热量或噪声。**

Photo by no one cares on Unsplash

2.收获

然后是收获的时候，也就是蔬菜或水果成熟的时候。

这相当于数据收集**，意味着浏览器或传感器会将用户动作或触发传感器的事件转化为实际数据。**

Photo by Matthew T Rader on Unsplash

3.运送

收获后，产品必须运输到目的地，用作我们披萨的配料。

这相当于将数据接收到一个存储库中，稍后将从那里获取数据，比如数据库或数据湖。

Photo by Nicolas Gras on Unsplash

4.选择器具和器皿

对于每一种配料**，都有最合适的器具来处理。如果需要切片，使用刀。如果需要搅拌，一把勺子。同样的道理也适用于器具:如果你需要烘烤，使用烤箱。如果需要炒，一个灶。你也可以使用更复杂的设备，如微波炉，有更多的设置选项。**

有时候，使用更简单的设备甚至会更好——你见过餐馆做广告说“微波披萨”吗？！我没有！****

在机器学习中，器具是预处理数据的技术，而器具是算法，就像线性回归或随机森林。还可以用一个微波，我是说深度学习。可用的不同选项是超参数。在简单的电器里只有几个，我是说算法。但是在一个复杂的世界里还有很多很多。此外，无法保证复杂的算法会带来更好的性能(或者你更喜欢微波披萨？！).所以，明智地选择你的算法。****

Photo by S O C I A L . C U T on Unsplash

5.选择食谱

光有食材和器具是不够的。你还需要一份食谱**，里面有你准备菜肴需要遵循的所有步骤。**

这是你的型号**。而没有，你的型号是不是跟你的算法一样。该模型包括您的算法所需的所有前置 -后置--加工。并且，说到预处理 …**

Photo by Caroline Attwood on Unsplash

6.准备配料

我敢打赌，大多数食谱中的第一个说明是这样的:“切这个”，“削那个”等等。他们不会告诉你去洗蔬菜，因为这是理所当然的——没人想吃脏的蔬菜，对吧？

数据也是如此。没人想要脏数据。你要清理它，也就是处理缺失值和离群值**。然后你要剥和切片，我的意思是预处理，就像编码分类变量(男或女)成数值( 0 或 1 )。**

没人喜欢那部分。数据科学家和厨师都不是(我猜)。

Photo by Bonnie Kittle on Unsplash

7.特殊准备

有时候，你可以用你的配料获得创意**，以获得更好的口味或更精致的 呈现。**

你可以将牛排风干以获得不同的味道，或者将胡萝卜雕刻成玫瑰的形状，然后放在你的盘子上:-)。

这是特色工程**！这是一个重要的步骤，如果用一种巧妙的方式，可能会大大提高你的模型的性能。**

几乎每个数据科学家都喜欢这一部分。我猜厨师也喜欢它。

Photo by Clem Onojeghuo on Unsplash

8.烹饪

最基本的一步——没有真正的烹饪**，就没有菜肴。很明显。你把准备好的配料放入器具，调整热度，等一会儿再检查。**

这是你模型的训练**。您将数据输入到您的算法，调整其超参数并等待一段时间，然后再次检查。**

Photo by Icons8 team on Unsplash

9.品尝

即使你严格按照菜谱做，你也不能保证一切都是正确的。那么，你怎么知道你是否做对了呢？你尝尝吧！如果不好吃，可以多加盐尝试修复。您也可以改变温度。但是你继续做饭！

不幸的是，有时你的披萨会被烧焦，或者不管你怎么做都难以下咽。你把它扔进垃圾桶，从错误中吸取教训，重新开始。

但愿，坚持和一点点运气能做出美味** 披萨 😃**

品鉴就是评价。你需要评估你的模型，检查它是否运行良好。如果没有，您可能需要添加更多功能。您也可以更改一个超参数。但是你要坚持训练！

不幸的是，有时你的模型不会收敛到一个解决方案，或者做出可怕的预测，不管你做什么来试图挽救它。你抛弃了你的模型，从你的错误中吸取教训，重新开始。

希望，坚持和一点点运气会产生一个高性能模型** 😃**

Photo by Kai Pilger on Unsplash

10.递送

从厨师的角度来看，他/她的工作已经完成了。他/她做了美味的比萨饼。句号。

但是如果比萨饼没有很好地送到顾客手中，及时送到顾客手中，比萨饼店就会倒闭，厨师也会失业。

比萨饼做好之后，必须立即包装好以保温，并小心地处理好，以免在送到饥饿的顾客手中时看起来湿漉漉的。如果骑车人没有到达他/她的目的地，在路上丢失了比萨饼或者把它摇得面目全非，所有的烹饪努力都是徒劳的。

交付就是部署。不是披萨，而是预测。预测就像披萨一样，必须包装**，不是装在盒子里，而是作为数据产品，这样才能送到热切的顾客手中。如果管道出现故障、中途断裂或以任何方式修改预测，所有的模型训练和评估都是徒劳的。**

就是这样！机器学习就像烹饪食物——过程中有几个人参与，需要付出很多努力**，但最后的结果却可以好吃！**

只有几个要点:

• 如果食材是坏的**，那菜就要坏了——没有菜谱能搞定 那当然，没有器具，也没有；**
• 如果你是厨师**，千万不要忘记，不送，烹饪就毫无意义，因为永远不会有人品尝你的美味；**
• 如果你是一个餐馆老板**，不要试图把电器强加给你的厨师——有时候 微波炉 并不是最好的选择——如果他/她把所有的时间花在洗碗和切片 配料上，你会得到一个非常不开心的厨师…**

我不知道你怎么样，但是我现在想要订购一个比萨饼！:-)

如果你有什么想法、评论或者问题，请在下方留言或者联系我 推特 。

了解用于移动应用程序开发的人工智能和 ML

原文：https://towardsdatascience.com/understanding-ai-and-ml-for-mobile-app-development-d07a3788d508?source=collection_archive---------7-----------------------

Photo by Rock'n Roll Monkey on Unsplah

上次我发表了这篇博客，其中我解释了 AI 和 ML 的一个应用——“视觉”，还简要解释了在移动开发中使用 ML kit，这是谷歌提供的云平台，用于集成 Android 和 iOS 应用中的 ML 功能。这篇文章是那篇文章的前传，在这篇文章中，我将解释人工智能和机器学习的基础知识。我将阐明什么是不同类型的机器学习，以及当我们看到谷歌照片应用程序检测我们的面部时，或者当 Gmail 建议我们用完整的句子作为回复时，这一切是如何发生的。

AI vs ML

人工智能和 ML 是计算机科学的一个分支，一个单独的博客无法对这些主题做出公正的评价，我也不自称是这些领域的专家，但是为了我们在移动应用程序中开始使用 ML 的目标，我们必须对这些术语有一些基本的理解。

人工智能被定义为——机器或计算机对人类行为的模仿。人工智能研究的是科学的一个分支，其目标是使机器或计算机表现出与人类同等水平的智力、聪明、表达能力和艺术特征。人工智能的水平和应用各不相同。现在，例如，如果有一个假设的人形机器人可以洗碗、洗车和做饭，我们将把它称为人工智能的产品，但也将是一个能够理解语音并识别语音语气是愤怒、羡慕还是高兴的软件。人工智能是巨大的，涉及许多方面——有帮助收集、分类和处理数据的数据科学，有帮助理解和应用智能特征的算法，还有机器学习。ML 是人工智能的一部分，它实现了学习和训练能够做出决策的程序的目标。这些程序被输入了大量的数据，使用算法来处理这些数据，并根据这些数据进行训练，这样当它得到一个新的输入时，它就能够做出决定。

Cat or Dog — Using neural network for vision

人工智能在最近几年变得越来越热门，但它不是新概念，自 70 年代以来就一直存在。但直到现在，由于高处理能力、硬件和所需的大量数据的可用性，它才变得切实可行地用于解决问题。为了训练模型并给出可靠的输出，ML 需要处理的数据项不是几千而是几百万。

ML 解释道

ML 可以分为三种方式:

1. 监督学习——我们向 ML 算法输入大量数据，这些数据被标记，即标有结果。该数据具有附在条目上的段或标签。在这种类型的学习中，我们教系统如何根据我们已经输入的数据来识别新的输入。
2. 无监督学习——数据没有被标记或分类。在这种情况下，系统不知道成功或失败终点，因为它没有任何可用的指导。在这种情况下，系统会尝试对可用数据进行分类，并用给定的信息创建模式，并存储这些模式。现在，当一个新的输入到达时，它会尝试将输入与存储的模式进行匹配，并将选择的模式分配给它。
3. 强化学习——这是一种无监督学习。在这种学习中，输入数据也没有标记。当获得成功时，它被反馈给系统以指示推断成功。这改善了未来的结果。

理解 ML 需要我们经历以下术语:

• 数据
• 模型
• 培养
• 决定
• 经验

ML 程序被输入大量的数据训练它。从训练中，它学习问题的规则，并积累经验。有了经验，当新问题出现时，它就有能力做出决定。此外，在处理新的数据和问题陈述时，它使适应新的情况。所以和人类一样，它“边工作边学习”。例如，如果我们必须使用机器学习来创建一个国际象棋解算器，我们将不会编写大量的 if/else 来对每一步做出决定，而是我们将为 ML 程序提供一些非常基本的规则以及大量以前的国际象棋游戏数据。有了这些数据，它将学习并最终能够决定下一步该做什么。

创建“模型”

创建和训练模型是创建您的 ML 系统的非常重要的部分。模型是预处理数据和选定算法的集合，这些算法对数据进行处理以推断输出。创建模型是一个复杂的过程，本质上是迭代的。对于我们的用例，我们从一些基本规则和选择的算法开始，并开始向我们的系统提供大量的使用数据。这些数据是我们以前在系统中收集的条目。例如，在银行欺诈检测系统的情况下，数据将是所有用户的信用和借记交易的历史。使用这些数据，我们首先创建不同的“候选模型”，然后在新的数据集上使用和尝试这些模型，并观察它们的性能。在成功率的基础上，选择和部署最佳的模型来提供新的用例。有了新的输入数据，选定的模型做出决策，并在此过程中收集更多的经验，使自己适应不断扩展的用例。

Training and using ML model

Creating ML model — iterative nature of the process

ML 的应用

• 图像处理——这是最典型的 ML 用例。在这个 ML 中，算法被用于检测给定图像中的各种对象。这属于“监督学习”,其中 ML 系统被输入大量包含不同对象的标记图像。因此，ML 模型被训练来识别对象。谷歌助手和谷歌照片就是很好的例子。AWS Rekognition 和 Firebase ML kit 为此功能提供了 API。
• 自然语言处理和语音识别——自然语言处理和语音识别是 ML 的另一个非常著名且不断发展的用例。检测书面文本并推断其脚本和含义是非常有用的。有各种解决方案可用于集成这一点，包括 Google Cloud ML 和 AWS 的不同产品——Amazon transcripte、Translate 和 Lex。
• 诊断学——医学诊断学是人工智能和人工智能领域的一个衍生因素。医疗部门和人工智能科学家开发了一些系统，可以使用细胞视觉和包括病历在内的其他数据来检测癌症和其他疾病的可能性。
• 预测—使用历史数据 ML 模型可以推断未来事件，如商业欺诈检测、客户行为预测或自然事件预测。

First painting created by an AI program

如何在应用中使用人工智能/人工智能——何去何从

有几个方向可供选择，这取决于开发人员想要多少功能、灵活性，以及他们的用例有多具体。我们可以从谷歌云或 AWS 平台的现成、完全成熟的人工智能产品中进行选择，也可以部署我们自己的定制模型。

ML 框架

• TensorFlow/Keras 模型——Tensor Flow 是谷歌的开源机器学习框架。张量流是一个通用的 ML 框架，涵盖了广泛的用例。这是最广泛用于开发和部署 ML 模型。Keras 是一个高级 Python API，用于构建和训练深度学习模型。它是独立开发的，但在谷歌收购后，现在是张量流的一部分。
• 来自脸书的 PyTorch 这个来自脸书的库是基于 Python 的深度学习库。这主要用于像自然语言处理这样的应用。这也是开源的。PyTorch 的主要优势在于它利用 GPU 的能力来解决复杂的数学问题。它被深度学习研究人员用作首选库。它可以说是早期著名的 Python 数学库的高级版本，是 numPy，但它更好更快，因为它使用了 GPU。
• Google Cloud ML/Cloud Vision——Google Cloud Vision 框架是 Google ML 产品的一部分，专门处理计算机视觉或“图像分析”。在这种情况下，有几种功能可用于图像分析，如文本检测、人脸检测、内容调节等。

Google Cloud Vision home

Cloud vision API demo

• Firebase ML kit with tensor flow Lite—Firebase ML kit 是 Cloud Vision API 的新成员，主要面向移动开发者。ML 工具包提供易于使用的云 API 的图像处理，如文本检测，人脸检测，条形码扫描，对象检测和标志检测。它提供了在设备上或云处理的选项。
• AWS 套件——AWS 还提供了大量现成的 ML 特性。这些功能包括图像分析(AWS Rekognition)、语音转文本(AWS Transcribe)、翻译(AWS Translate)、聊天机器人(AWS Lex)、文本转语音(AWS Polly)和许多其他功能。在这些 AWS 中，Rekognition 涵盖了与图像分析相关的最广泛的使用案例，如文本和对象识别、人脸检测和识别等。

AWS rekognition

• OpenCV —这是迄今为止最著名的计算机视觉和机器学习库，它非常强大，易于使用，并且是开源的。它适用于包括 Android 在内的不同平台。这个库非常容易使用，开发人员正在使用它来制作非常酷的计算机视觉相关应用程序，如检测人脸或特定对象，并在此基础上做出决定。
• kag gel——对于人工智能开发人员来说，这是一个非常有用的地方，可以为他们的特定用例获取数据集/模型。拥有超过 10，000 个数据集，以满足不同的需求和领域。例如，如果你想创建一个实时微笑检测器，你会想检查一个检测到的脸是否在微笑。您需要一个成熟的数据集来创建和准备您的模型。你会从卡格尔那里得到这个。Kaggle 于 2017 年被谷歌收购。

Kaggle datasets (www.kaggle.com)

TL；灾难恢复—如果您的需求属于图像分析、文本或识别或视频分析等一般使用情形，那么您可以使用 AWS 或 Google Cloud 提供的现成解决方案。如果您需要对现有模型进行一些调整，或者您想要部署现有模型，您可以使用 TensorFlow/Keras，如果您想要用自己的定制解决方案解决一个新问题，您可以使用 PyTorch 或 TF 创建和训练您的模型，并使用任何云解决方案部署它。Kaggel 是一个非常好的存储库，可以存储大量用例的数据。

了解和优化 gan(回到基本原则)

原文：https://towardsdatascience.com/understanding-and-optimizing-gans-going-back-to-first-principles-e5df8835ae18?source=collection_archive---------0-----------------------

Fig 1. Improvement of fake image generation of faces over training using basic GAN algorithm

自从 Ian Goodfellow 首次提出生成性对抗网络(GANs)架构以来，围绕该架构的宣传一直在增长，并且大量的进步和应用每天都变得越来越令人着迷。但是对于任何想开始使用 GANs 的人来说，想知道从哪里开始是相当棘手的。不要惊慌。这篇文章将指导你。

和许多事情一样，完全理解一个概念的最好方法是触及根本。抓住首要原则。对于甘斯来说，这里是原文->(https://arxiv.org/abs/1406.2661)。要理解这类论文，有两种方法，理论的和实践的。我通常更喜欢后者，但如果你喜欢深入研究数学，这里的是我的好友 Sameera 的一篇很棒的帖子，从理论上分解了整个算法。与此同时，本帖将使用 Keras 以最纯粹的形式呈现该算法的简单实现。让我们开始吧。

在 GAN 的基础设置中有两个模型，即生成器和鉴别器，其中生成器不断地与鉴别器竞争，鉴别器是正在学习区分模型分布(例如生成的假图像)和数据分布(例如真实图像)的对手。这个概念被一个伪造者对警察的场景形象化了，在这个场景中，生成模型被认为是伪造者生成假币，而鉴别模型被认为是警察试图检测假币。这个想法是，随着彼此之间的不断竞争，伪造者和警察都在彼此的角色中改进，但最终伪造者达到了生产与真钞难以区分的假钞的阶段。简单。现在让我们把它写成代码。

本文提供的示例脚本用于生成虚假的人脸图像。我们试图用该算法实现的最终结果如图 1 所示。

建立发电机模型

因此，发电机模型应该吸收一些噪声，并输出一个令人满意的图像。这里我们使用 Keras 序列模型以及密集和批量标准化层。使用的激活函数是 Leaky Relu。请参考下面的代码片段。发电机模型可以分为几个模块。由密集层->活化->批量归一化组成的一个块。添加了三个这样的块，最后一个块将像素转换成我们期望输出的图像的形状。该模型的输入将是形状为(100)的噪声向量，并且该模型在最后被返回。注意每个密集层中的节点是如何随着模型的进展而增加的。

建立鉴别器模型

鉴别器接收一个图像输入，将其展平并通过两个密集->激活模块，最终输出一个介于 1 和 0 之间的标量。输出 1 应该表示输入图像是真实的，否则为 0。就这么简单。参考下面的代码。

注意:-
你可以在以后修改这些模型，增加更多的模块，更多的批量标准层，不同的激活等等。根据这个例子，这些模型足以理解 GANs 背后的概念。

发现损失并训练

我们计算三个损失，在本例中全部使用二元交叉熵来训练两个模型。

首先是鉴别器。它被训练成两种方式，如下面的代码所示。首先为真实图像(数组“img”)输出 1，然后为生成的图像(数组“gen_img”)输出 0。随着训练的进行，鉴别器在这项任务上有所提高。但是我们的最终目标在理论上达到了，此时鉴别器对两种类型的输入都输出 0.5(即，不确定是假还是真)。

接下来是训练发电机，这是一个棘手的问题。为了做到这一点，我们首先公式化一个给定发电机输出的鉴别器的组合模型。记住！理想情况下，我们希望这个值为 1，这意味着鉴别器将生成的假图像识别为真实图像。所以我们针对 1 训练组合模型的输出。参见下面的代码。

现在我们来玩吧！这是代码的要点，可以简单地理解 GANs 的工作方式。

完整代码可以在我的 GitHub 上 这里 找到。您可以参考所有用于导入 RGB 图像、初始化模型并将结果记录在代码中的附加代码。还要注意，在训练期间，小批量被设置为 Hi32 图像，以便能够在 CPU 上运行。
此外，示例中使用的真实图像是来自 CelebA 数据集的 5000 幅图像。这是一个开源的数据集，我已经把它上传到我的 Floydhub 上以便于下载，你可以在这里找到。***

有许多方法可以优化代码以获得更好的结果，并了解算法的不同组件如何影响结果的效率。观察结果，同时调整不同的组件，如优化器，激活器，规格化，损失计算器，超参数等，是增强你对算法理解的最好方法。我选择改变优化。

因此，我以 32 个为一批，训练了 5000 个纪元，用三种优化算法进行了测试。使用 Keras，这个过程就像导入和替换优化器函数的名称一样简单。所有 Keras 内置的优化器都可以在这里找到。
还绘制了每种情况下的损失，以了解模型的行为。

1. 使用 SGD(随机梯度下降优化器)。输出和损耗变化分别如图 2 和图 3 所示。

Fig 2. Output of the GAN using SGD as the optimizer

Fig 3. Plot showing the variation of losses while training the GAN using SGD

注释——虽然收敛有噪声，但我们可以看到，发生器损耗随着时间的推移而下降，这意味着鉴别器倾向于将假图像检测为真图像。

2.使用 RMSProp 优化器。输出和损耗变化分别如图 4 和图 5 所示。

Fig 4. Output of the GAN using RMSProp as the optimizer

损失:

Fig 5. Plot showing the variation of losses while training the GAN using RMSProp

注释—这里我们还可以看到发电机损耗在下降，这是一件好事。令人惊讶的是，真实图像上的鉴别器损耗增加了，这非常有趣。

3.使用亚当优化器。输出和损耗变化分别如图 6 和图 7 所示。

Fig 6. Output of the GAN using Adam as the optimizer

Fig 7. Plot showing the variation of losses while training the GAN using Adam

注释 adam 优化器产生了迄今为止最好的结果。请注意鉴别器对假图像的损失如何保持较大的值，这意味着鉴别器倾向于将假图像检测为真图像。

评论

我希望这篇文章从实用的角度传达了对 GANs 内部工作的基本看法，以理解和了解如何改进基本模型。在不同的应用程序上，开源社区中有许多 GANs 的实现，对基本原则有一个良好的理解将极大地帮助你理解这些进步。此外，GANs 对于深度学习来说相对较新，有许多研究途径对任何感兴趣的人开放。

所以你可以探索无限的可能性！

了解和可视化 DenseNets

原文：https://towardsdatascience.com/understanding-and-visualizing-densenets-7f688092391a?source=collection_archive---------1-----------------------

这篇文章可以在 PDF 这里下载。

这是关于 CNN 架构的系列教程的一部分。

主要目的是深入了解 DenseNet，并深入研究针对 ImageNet 数据集的 DenseNet-121。

• 对于适用于 CIFAR10 的 DenseNets，这里还有另外一个教程。

索引

• 背景
• 动机
• DenseNets 解决什么问题？
• 体系结构
• 摘要

背景

密集连接的卷积网络1，DenseNets，是继续增加深度卷积网络的下一步。

我们已经看到我们是如何从 5 层的 LeNet 发展到 19 层的 VGG 和超过 100 层甚至 1000 层的 ResNets。

动机

当 CNN 更深入时，问题就出现了。这是因为 路径 对于从输入层直到输出层的信息(对于反方向的渐变) 变得如此之大 ，以至于它们可以在到达另一边之前 消失 。

DenseNets 简化了其他架构中引入的层之间的连接模式:

• 高速公路网2
• 剩余网络3
• 分形网络[4]

作者解决了确保最大信息(和梯度)流的问题。为此，他们只需将每一层直接相互连接。

DenseNets 没有从极深或极宽的架构中汲取代表力量，而是通过功能重用来挖掘网络的潜力。

DenseNets 解决什么问题？

反直觉地，通过这种方式连接，densentes比等效的传统 CNN 需要更少的参数 ，因为不需要学习冗余的特征映射 。

此外，ResNets 的一些变体已经证明许多层几乎不起作用，并且可以被丢弃。事实上，ResNets 的参数数量很大，因为每一层都有其要学习的权重。相反， DenseNets 图层很窄 (例如 12 个滤镜)，它们只是 增加了一小组新的特征贴图 。

非常深的网络的另一个问题是训练的问题，因为提到了信息流和梯度。DenseNets 解决了这个问题，因为 每一层都可以从损失函数 和原始输入图像直接访问梯度。

结构

Figure 1. DenseNet with 5 layers with expansion of 4. 1

传统的前馈神经网络在应用操作 的 组合后，将该层的输出连接到下一层。

我们已经看到，通常这个组合包括一个卷积运算或池层、一个批处理规范化和一个激活函数。

这个等式是:

ResNets 扩展了这种行为，包括跳过连接，将该等式重新表述为:

DenseNets 与 ResNets 的第一个区别就在这里。 DenseNets 不将该层的输出特征图与输入特征图相加，而是将它们连接起来。

因此，该等式再次变形为:

我们在 ResNets 上的工作面临着同样的问题，当它们的尺寸不同时，这种特征地图的分组就不能完成。不管分组是相加还是串联。因此，和我们用于 ResNets 的方法一样，DenseNets 被分成 DenseBlocks，其中特征映射的尺寸在一个块内保持不变，但是过滤器的数量在它们之间变化。它们之间的这些层被称为 过渡层 ，并负责应用批量归一化、1x1 卷积和 2x2 合并层的下采样。

现在我们可以开始讨论增长率了。由于我们正在连接特征图，该信道维度在每一层都在增加。如果我们使 H_l 每次产生 k 个特征图，那么我们可以对第 l 层进行推广:

这个超参数 k 就是增长率。增长率决定了每层网络中增加的信息量。为什么

我们可以把特征图看作是网络的信息。 每一层都可以访问其前面的特征图 ，因此，对 集合知识 。然后，每一层都向这一集体知识添加新的信息，具体表现为信息的 k 特征图

DenseNets-B

DenseNets-B 只是常规 DenseNets，它利用 1x1 卷积来减少 3x3 卷积之前的特征映射大小，并提高计算效率。B 出现在瓶颈层之后，你已经熟悉这个名字了，来自ResNets的工作。

丹麦-公元前

DenseNets-C 是 DenseNets-B 的另一个小增量步骤，用于我们想要 减少输出特征映射 的情况。 ***压缩因子(θ)**决定了这个减少量。我们将拥有 thetam，而不是某一层的 m 个特征地图。当然，在范围[0–1]内。所以当θ= 1时，DenseNets 将保持不变，否则将是 DenseNets-B。

为了与resnet 上的工作保持一致，我们将详细讨论 ImageNet 数据集上的案例。然而，CIFAR-10 或 SVHN 的结构更简单，因为输入量更小。

Figure 2. Sizes of outputs and convolutional kernels for different DenseNets 1 architectures on ImageNet.

正如您从之前关于其他体系结构的工作中了解到的，我更喜欢观察模型中的卷实际上是如何改变其大小的。这种方式更容易理解特定模型的机制，能够根据我们的特定需求对其进行调整。我将尝试遵循接近于 PyTorch 官方实现的符号，以便于稍后在 PyTorch 上实现它。

密集和过渡块

然而，由于 DenseNets 上的高密度连接，可视化变得比 VGG 和雷斯内特更复杂一些。图 3 显示了 DenseNet-121 架构的一个非常简单的方案，这将是我们在这项工作中重点关注的 DenseNet。这是因为它是在 ImageNet 数据集上设计的最简单的 DenseNet。

我们可以在 DenseNet-121 上比较图 3 和图 2。每个体积下的尺寸代表宽度和深度的大小，而顶部的数字代表特征地图的尺寸。我介绍了它们是如何派生出来的，以帮助我们更好地理解即将到来的步骤。

Figure 3. Another look at Dense-121. Dx: Dense Block x. Tx: Transition Block x.

您可能想知道整个 DenseNet 的旁路连接在哪里，您问对了！然而，我只是想先画一个最简单的方案，以便更深入地了解 DenseNet 的整个结构。但是出于好奇，您可以注意到计算每个新卷的特征映射的加法的第一个数字是如何与前一卷的特征映射维度相匹配的。这将解释旁路连接，因为它确切地意味着我们正在将串联(串联意味着添加维度，但不是添加值！)新信息到上一卷，也就是被重用的。

请注意， 32 正是我们在本节开始时提到的增长率。那么，从上图我们能得到什么呢？

—每个密集块之后的体积增加了增长率乘以该密集块内的密集层数

在图 4 中，我们现在更深入地了解了每个块中实际发生的事情。

Figure 4. One level deeper look at DenseNet-121. Dense Block and Transition Block. DLx: Dense Layer x

致密层

现在，我们可以理解上面的说法了。每一层都在前一卷的基础上增加了 32 张新的特征地图。这就是我们在 6 层之后从 64 到 256 的原因。此外，过渡块执行 128 个滤波器的 1x1 卷积。随后是步长为 2 的 2×2 池，导致将体积的大小和特征图的数量对半分割。我们可以从这种模式观察中得出新的结论。

—致密块内的体积保持不变—

—在每个过渡块之后，体积和特征图减半—

不过，我们还可以再深入一层！我们需要了解每个密集块中的每个密集层内部发生了什么，因为这还不是小事。让我们一起去看全图吧！

Figure 5. 2 level deep. Full schematic representation of ResNet-121

在表示第一个密集块中的第一个密集层的新的更深层次中，我们可以看到添加 32 倍层数的行为实际上是如何实现的。我们执行作者建议的 128 个滤波器的 1×1 卷积，以减小*特征图的大小，并执行更昂贵的 3×3 卷积(记得包括填充以确保尺寸保持不变),具有选择的 32 个增长率特征图。

然后，在向网络的公共知识添加新信息的动作中，输入量和两个操作的结果(对于每个密集块内的每个密集层是相同的)被连接。

引用的作品

1 G .黄，z .刘，l .范德马腾，“密集连接卷积网络”，2018 .

2 R. Kumar，K. Gredd 和 J. Schmidhuber，“高速公路网络”，2015 年。

3何国光，张，任，孙健，“深度残差学习在图像识别中的应用”，2015 .

[4] G. Larsson，M. Maire 和 G. Shakhnarovich，“FractalNet:无残差的超深度神经网络”，2017 年。

理解和可视化资源

原文：https://towardsdatascience.com/understanding-and-visualizing-resnets-442284831be8?source=collection_archive---------1-----------------------

这篇文章可以在 PDF 这里下载。

这是关于 CNN 架构的系列教程的一部分。

主要目的是深入了解 ResNet，并深入研究 ResNet34 for ImageNet 数据集。

• 对于应用于 CIFAR10 的 ResNets，这里还有另外一个教程。
• 还有 PyTorch 实现详细教程这里。

索引

• 背景
• 动机
• ResNets 解决什么问题？
• 体系结构
• 摘要

背景

研究人员观察到，当涉及到卷积神经网络时，肯定“*越深越好”*是有意义的。这是有意义的，因为模型应该更有能力(它们适应任何空间增加的灵活性，因为它们有更大的参数空间来探索)。然而，已经注意到，在一定深度之后，性能会下降。

这是 VGG 的瓶颈之一。他们不能达到预期的深度，因为他们开始失去归纳能力。

动机

由于神经网络是良好的函数逼近器，它们应该能够容易地求解识别函数，其中函数的输出成为输入本身。

按照同样的逻辑，如果我们绕过模型第一层的输入，作为模型最后一层的输出，网络应该能够预测它之前学习的函数和添加的输入。

直觉告诉我们，学习 f(x) = 0 对网络来说一定很容易。

ResNets 解决什么问题？

ResNets 解决的问题之一就是著名的已知 消失渐变 。这是因为当网络太深时，在链规则的几次应用之后，计算损失函数的梯度容易收缩到零。这导致权重永远不会更新其值，因此没有学习被执行。

有了 ResNets，渐变可以直接通过跳过连接从后面的层向后流到初始过滤器。

体系结构

Figure 1. ResNet 34 from original paper 1

由于 ResNet 可以具有可变的大小，这取决于模型的每一层有多大，以及它有多少层，我们将遵循作者在论文1 — ResNet 34 中描述的，以便解释这些网络之后的结构。

如果你看了一下这篇论文，你可能会看到一些如下的图表，你很难理解。让我们通过研究每一步的细节来描绘这些数字。

在这里，我们可以看到 ResNet(右边的那个)由一个卷积和合并步骤(在 orange 上)组成，后面是 4 层类似的行为。

每一层都遵循相同的模式。它们分别与固定的特征映射维度(F) [64，128，256，512]执行 3×3 卷积，每两次卷积绕过输入。此外，宽度(W)和高度(H)尺寸在整个层中保持不变。

虚线在那里，正是因为输入体积的维度发生了变化(当然是因为卷积而减少)。注意，层与层之间的这种减少是通过在每层的第一个回旋处将步幅从 1 增加到 2 来实现的；而不是像我们习惯看到的下采样器那样通过汇集操作。

在该表中，总结了每一层的输出大小以及该结构中每一点的卷积核的维数。

Figure 2. Sizes of outputs and convolutional kernels for ResNet 34

但这是不可见的。我们想要图像！一张图片胜过千言万语！

图 3 是我更喜欢看到卷积模型的方式，从这里我将解释每一层。

我更喜欢观察通过模型的体积是如何改变它们的大小的。这种方式更容易理解特定模型的机制，能够根据我们的特定需求进行调整——我们将看到仅仅改变数据集如何迫使改变整个模型的架构。此外，我将尝试遵循接近于 PyTorch 官方实现的符号，以便稍后在 PyTorch 上实现它时更容易。

例如，论文中的 ResNet 主要针对 ImageNet 数据集进行解释。但是我第一次想用 ResNets 的集合做实验时，我不得不在 CIFAR10 上做。显然，由于 CIFAR10 输入图像是(32x32)而不是(224x224)，因此需要修改 ResNets 的结构。如果您想控制应用到您的 ResNet 的修改，您需要了解细节。这另一个教程是当前应用于 CIFAR10 的一个简化版。

所以，我们一层一层来！

Figure 3. Another look at ResNet 34

卷积 1

在进入公共层行为之前，ResNet 上的第一步是一个块(此处称为 Conv1 ),由卷积+批处理规范化+最大池操作组成。

如果你不记得卷积和池操作是如何执行的，快速看一下我画的这个图来解释它们，因为我在这里重用了它们的一部分。

首先有一个卷积运算。在图 1 中，我们可以看到他们使用的内核大小为 7，特征映射大小为 64。您需要推断它们在每个维度上用零填充了 3 次——并在 PyTorch 文档中进行检查。考虑到这一点，从图 4 中可以看出，该操作的输出大小将是一个(112x122)卷。由于(64 个中的)每个卷积滤波器在输出音量中提供一个通道，因此我们最终得到(112x112x64)的输出音量——注意，为了简化说明，这不包括批次维度。

Figure 4. Conv1 — Convolution

下一步是批处理规范化，这是一个基于元素的操作，因此不会改变卷的大小。最后，我们有一个跨度为 2 的(3x3)最大池操作。我们还可以推断，他们首先填充输入体积，因此最终体积具有所需的尺寸。

Figure 5. Conv1 — Max Pooling

ResNet 层

所以，我们来解释一下这个重复的名字，block。一个 ResNet 的每一层都由几个块组成。这是因为当 ResNets 更深入时，它们通常通过增加块内的操作数量来实现，但总层数保持不变，即 4 层。 这里的运算是指对一个输入进行卷积、批量归一化和 ReLU 激活，除了最后一个没有 ReLU 的块的运算。

因此，在 PyTorch 实现中，他们区分包含 2 个操作的块基本块和包含 3 个操作的块瓶颈块。注意，通常这些操作中的每一个都被称为层，但是我们已经为一组块使用了层。

我们现在面临一个基本问题。输入音量是 Conv1 的最后一个输出音量。让我们看看图 6，看看这个模块内部发生了什么。

第一区

1 卷积

我们正在复制纸上每一层的简化操作。

Figure 6. Layer 1, block 1, operation 1

我们现在可以仔细检查我们使用的[3x3，64]内核和输出大小为[56x56]的论文中的表格。我们可以看到，正如我们前面提到的，在一个数据块中，卷的大小是如何保持不变的。这是因为使用了填充= 1，并且跨距也是 1。让我们看看这如何扩展到整个块，以覆盖表中出现的 2 [3x3，64]。

Figure 7. Layer 1, block 1

相同的过程可以扩展到整个层，如图 8 所示。现在， 我们可以完整的读取 表格的整个单元格了(只是重述一下我们在 Conv2_x 层的 34 层 ResNet 中。

我们可以看到如何在层 中使用***【3x 3，64】x 3 次。***

Figure 8. Layer 1

模式

下一步是从整个块升级到整个层。在图 1 中，我们可以看到这些层是如何通过颜色区分的。但是，如果我们观察每一层的第一个操作，我们会发现第一层使用的步幅是 2，而不是其他层使用的 1。

这意味着通过网络的音量的 下采样是通过增加步幅来实现的，而不是像通常的 CNN 那样的汇集操作 。事实上，在我们的 Conv1 层中只执行了一次最大池化操作，在 ResNet 的末尾，就在图 1 中完全连接的密集层之前，执行了一次平均池化操作。

我们还可以看到 ResNet 层上的另一个重复图案，点层代表维度的变化。这和我们刚才说的一致。每一层的第一个操作是减少维度，因此我们还需要调整通过跳过连接的卷的大小，这样我们就可以像图 7 中那样添加它们。

这种跳过连接上的差异在文中被称为 恒等式快捷方式 和 投影快捷方式 。恒等快捷方式是我们已经讨论过的，简单地绕过加法运算符的输入量。投影快捷方式执行卷积运算，以确保此加法运算中的体积大小相同。从纸上我们可以看到 匹配 输出尺寸有两种选择。或者 填充输入音量 或者执行 1x1 卷积 。这里显示了第二个选项。

Figure 9. Layer2, Block 1, operation 1

图 9 显示了通过将跨距增加到 2 来执行的下采样。滤波器的数量被加倍，以试图保持每个操作的时间复杂度( 5664 = 28128 )。另外，请注意，由于卷被修改，现在无法执行添加操作。在捷径中，我们需要应用一种下采样策略。1x1 卷积方法如图 10 所示。

Figure 10. Projection Shortcut

最终的图片如图 11 所示，其中每个线程的 2 个输出卷大小相同，可以相加。

Figure 11. Layer 2, Block 1

在图 12 中，我们可以看到整个第二层的全局情况。下面的第 3 层和第 4 层的行为完全相同，只是改变了引入体积的尺寸。

Figure 12.Layer 2

摘要

遵循作者建立的解释规则的结果产生了如图 2 所示的以下结构:

Table 1. ResNets architectures for ImageNet

文献学

1何国光，张，任，孙，“深度残差学习在图像识别中的应用”，，，2016。

理解和可视化 SE-net

原文：https://towardsdatascience.com/understanding-and-visualizing-se-nets-1544aff0fc68?source=collection_archive---------8-----------------------

这篇文章可以在 PDF 这里下载。

这是 CNN 架构系列文章的一部分。

主要目的是提供理解 SE-Nets 的洞察力。

指数

(1)有哪些创新点？

• 新数据块与新网络
• 解决什么问题？
• 什么是 SE 块？

(2)结构

• 转换
• 挤压
• 激发，兴奋
• 缩放比例

(3)SE 模块的应用

(4)结果和结论

(5)全球图景

有哪些创新？

新块而不是新网络

首先，本文作者并没有试图通过开发一种新颖的 CNN 架构来提高经典计算机视觉竞赛的艺术水平。然而，非常有趣的是，作者创建了一个可以与现有模型一起使用的模块来增强它们的性能。

这个新的模块在完成两个主要操作后被命名为 SE 模块:挤压和激励

动机——这些积木解决了什么问题？

作者声称卷积的输出导致与滤波器捕获的空间相关性纠缠的信道依赖性。哇，这听起来太疯狂了！但是不要担心，在一些想象之后，这变得非常简单。

那么作者想用这些积木做什么来解决这个问题呢？

— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —

他们的目标是通过利用选通网络对通道相互依赖性进行显式建模来提高网络的灵敏度，选通网络出现在 se 模块中

— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —

那么什么是 SE 块呢？

简而言之，SE 模块是通道关系中的轻量级门控机制。

简而言之，网络现在能够学习如何理解在卷积运算【1】之后提取的所有特征图的堆栈中的每个特征图的重要性，并且在将卷传递到下一层之前重新校准该输出以反映该重要性。

所有这些都将在结构部分详细介绍，所以如果您现在没有看到某些内容，也不必担心！

但是等一下，为了学习，我们需要更多的参数，对吗？

没错。门控机制或门控网络只不过是完全连接的层。这种技术在注意机制中被大量使用。我强烈推荐这篇文章来更好地理解注意力机制和门控网络。

结构

让我们首先来看看图 1 中的图。我们可以称这个图为简化图，因为我们总是想要更多的细节！

Figure 1. The SE Block from the paper.

它显示了所提供的插图，我在上面分离了它的三个主要部分。重要的是要看到，挤压和激励步骤只发生在中间模块，而第一个和最后一个模块执行不同的操作。

在一次展示详细的图片之前，让我们一部分一部分地阐述它。

1 —转换

该转换简单地对应于将要实现 SE 模块的网络在其自然方案中执行的操作。例如，如果你在一个 ResNet 内的一个块中， F tr 项将对应于整个残差块的处理(卷积、批量归一化、ReLU…)。因此:

— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —

SE 块应用于变换操作的输出体，通过校准提取的特征来丰富它。

— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —

因此，如果 ResNet 在某个点将输出卷 X，则 SE 块丰富它包含的信息，并传递到下一层，成为 X`。(不能包含上面带~的 X)。

为了简化可视化，让我们假设变换是一个简单的卷积运算。我们已经在之前的文章中描述了卷积运算，但是，让我们试着稍微详细一点，以便更好地理解接下来会发生什么。

我之所以声称这第一步很重要，是因为作者构建 se 块的动机就在于此。

— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —

对于常规卷积层，是一组滤波器**被学习来表达沿着输入通道的局部空间连通性模式* X 因此卷积滤波器是局部感受域 内的 通道方式信息的组合。*

— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —

如果我们看一下对应于图 2 的符号，我们有:

— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —

他们所说的 局部感受野 恰恰是每个通道 2 的空间Vc，s 在每个过滤器c .

— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —

为什么信息是渠道方面的？

嗯，请注意滤波器 V 1 的标记 V 1，s 将仅在输入音量 X s 的通道 s 上卷积。

Figure 2. Step1: Transformation

我们也可以按通道来表示卷积运算，以进行双重检查:

在体积 X 中卷积 1 个单个滤波器 Vc 的结果在单个特征图上， U c:

换句话说，一个滤波器在体积 X 上的卷积是输入体积 X s 的每个通道与其在滤波器 V c，s 中的对应通道的所有通道卷积的总和

2 —挤压

挤压步骤可能是最简单的一步。它基本上在每个通道上执行平均汇集，以创建一个 1x1 压缩的卷 U 表示。****

Figure 3. Squeezing

3 —激发

这是 SE 模块整个成功的关键部分，所以请注意。这确实是一个文字游戏，我们将使用一个使用门控网络的注意力机制: )

作者引入了一个称为缩减比** r 的新参数，在 sigmoid 激活的选通网络之前，引入第一个具有 ReLU 激活的全连接(FC)层。**

这样做的原因是引入一个瓶颈，它允许我们在引入新的非线性的同时降低维度。

此外，我们可以更好地控制模型的复杂性和辅助网络的泛化性能。

具有两个 FC 层将导致具有两个权重矩阵，这两个权重矩阵将由网络在训练期间以端到端的方式学习(所有权重矩阵都与卷积核一起反向传播)。

该函数的数学表达式得出:

我们已经让我们的压缩特征地图兴奋了！

看看这些激励只不过是一对经过训练的神经网络，以便在训练过程中更好地校准这些激励。

3.规模

最后一步，缩放，确实是重新缩放操作。我们将赋予压缩矢量其原始形状，保持在激发步骤中获得的信息。

Figure 5. Rescaling

在数学上，缩放是通过输入体积上的每个通道与激活的 1x1 压缩向量上的相应通道的简单标量积来实现的。

对于 1 个频道:

作者讨论:

激活充当适应于输入特定描述符 z 的通道权重。

硒块的应用

如作为创新之一介绍的，SE 块不是新的神经网络架构。它试图通过使现有模型对渠道关系更加敏感来改进现有模型。

Figure 6. SE block applied to Inception (left) and ResNets (right) modules

图 6 显示了如何在卷积层的输出音量之后应用相同的 SE 块，以在将其移动到下一层之前丰富其表示。在这种情况下，显示了 Inception 和 ResNets 模块。

结果和结论

结果证实，在最先进的网络中引入 SE 块提高了它们在不同计算机视觉应用中的性能:图像网络分类、场景分类(Places365-Challenge 数据集)和对象检测(COCO 数据集)。这些结果太宽泛了，不包括在这个总结中，我建议在原始论文中查看它们。

****折减系数的经验研究值带来了一个有趣的观察结果。事实证明，16 是一个很好的值，超过这个值，性能不会随着模型容量的增加而单调地提高。

— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —

SE 块可能会过度拟合通道相关性

— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —

最后，作者在每个阶段(或层)对 50 个均匀采样的通道执行平均激活，其中为 5 个显著不同的类别引入了 SE 块。已经观察到，跨不同类别的分布在较低层中几乎相同，而每个通道的值在更大深度处变得更加类别特定。****

全球图片

将所有东西放回一起，SE 块: )

理解并使用 R 编写您的第一个文本挖掘脚本

原文：https://towardsdatascience.com/understanding-and-writing-your-first-text-mining-script-with-r-c74a7efbe30f?source=collection_archive---------3-----------------------

介绍

数据科学变得流行的原因之一是因为它能够在瞬间或仅仅一个查询中揭示大量数据集的信息。

仔细想想，每天我们以文本的形式给出了多少信息？所有这些信息包含了我们的情感、我们的观点、我们的计划、建议、我们最喜欢的短语等等。

然而，揭示其中的每一个看起来就像是大海捞针，直到我们使用像文本挖掘/分析这样的技术。

文本挖掘考虑了信息检索、词频分析和研究以及模式识别，以帮助可视化和预测分析。

在本文中，我们将经历数据集为进一步分析做准备的主要步骤。我们将使用 R 编写脚本，代码将在 R studio 中编写。

为了实现我们的目标，我们将使用一个名为“tm”的 R 包。这个软件包支持所有的文本挖掘功能，如加载数据，清理数据和建立一个术语矩阵。它在 CRAN 上有售。

让我们首先在我们的工作空间中安装并加载这个包。

#downloading and installing the package from CRAN
install.packages("tm")#loading tm
library(tm)

加载数据

要挖掘的文本可以从不同的源格式加载到 R 中。它可以来自文本文件(。txt)、pdf(。pdf)、csv 文件(。csv) e.t.c，但不管源格式如何，要在 tm 包中使用它，就要把它变成一个“语料库”。

语料库被定义为“书面文本的集合，尤其是特定作者的全部作品或关于特定主题的写作主体”。

tm 包使用 Corpus()函数创建一个语料库。

#loading a text file from local computer
newdata<- readlines(filepath)#Load data as corpus
#VectorSource() creates character vectorsmydata <- Corpus(VectorSource(newdata))

参考本指南了解更多关于导入文件到 r。

正在清理数据。

一旦我们成功地将数据加载到工作空间中，就该清理这些数据了。我们在这一步的目标是从数据文件中创建独立的术语(单词),然后才能开始计算它们出现的频率。

因为 R 是区分大小写的，我们应该首先将整个文本转换成小写，以避免认为相同的单词“write”和“Write”不同。

我们将删除:网址，表情符号，非英语单词，标点符号，数字，空白和停用词。

停用词:tm 包中常用的英文单词如“a”、“is”、“The”都称为停用词。为了使结果更准确，必须去掉这些词。也可以创建自己的自定义停用词。

# convert to lower case
mydata <- tm_map(mydata, content_transformer(tolower))#remove ������ what would be emojis
mydata<-tm_map(mydata, content_transformer(gsub), pattern="\\W",replace=" ")# remove URLs
removeURL <- function(x) gsub("http[^[:space:]]*", "", x)
mydata <- tm_map(mydata, content_transformer(removeURL)
)
# remove anything other than English letters or space
removeNumPunct <- function(x) gsub("[^[:alpha:][:space:]]*", "", x)
mydata <- tm_map(mydata, content_transformer(removeNumPunct))# remove stopwords
mydata <- tm_map(mydata, removeWords, stopwords("english"))#u can create custom stop words using the code below.
#myStopwords <- c(setdiff(stopwords('english'), c("r", "big")),"use", "see", "used", "via", "amp")
#mydata <- tm_map(mydata, removeWords, myStopwords)# remove extra whitespace
mydata <- tm_map(mydata, stripWhitespace)# Remove numbers
mydata <- tm_map(mydata, removeNumbers)# Remove punctuations
mydata <- tm_map(mydata, removePunctuation)

词干

词干提取是将相似来源的单词聚集成一个单词的过程，例如“通信”、“交流”、“沟通”。词干分析通过删除后缀和将单词简化为基本形式来帮助我们提高挖掘文本的准确性。我们将使用雪球图书馆。

library(SnowballC)mydata <- tm_map(mydata, stemDocument)

构建术语矩阵并揭示词频

在清理过程之后，我们剩下的是存在于整个文档中的独立术语。这些都存储在一个矩阵中，显示它们的每一次出现。这个矩阵记录了术语在我们的干净数据集中出现的次数，因此被称为术语矩阵。

#create a term matrix and store it as dtm
dtm <- TermDocumentMatrix(mydata)

词频:词在数据集中出现的次数。使用术语矩阵中出现的汇编，词频将向我们指示从数据集中最频繁使用的词到最少使用的词。

结论

我们刚刚写了一个基本的文本挖掘脚本，然而这只是文本挖掘的开始。获取原始格式的文本并将其清理到这一点的能力将为我们提供方向，如构建单词云、情感分析和构建模型。

保留这个脚本，因为当我们开始进行情感分析时，它会派上用场。

有任何问题都可以联系我> @lornamariak 。

使用 Valenbisi(瓦伦西亚自行车共享系统)了解 ARIMA 车型

原文：https://towardsdatascience.com/understanding-arima-models-using-valenbisi-valencias-bike-share-system-dcbe13b3e8a?source=collection_archive---------8-----------------------

我杰出的同事 Nicole Eickhoff 和我一起去西班牙，我们希望在那里见到数据科学家。因为我们会在那里参加 Fallas，一个为期一个月的社区和传统庆祝活动，我们收集了 Valenbisi 在 Crida Fallas 前一周的数据。Crida Fallas 是为期一个月的活动的第一天。我们想看看瀑布如何影响自行车共享活动。在这里，我详细介绍了我们在 2018 年 3 月 13 日星期二与巴伦西亚大数据会议上介绍和讨论的项目。

As part of the celebration of Fallas, each neighborhood in Valencia creates fantastic street light displays.

在这篇博客中，我简要描述了我使用刮刀收集数据、进行 ARIMA 分析、仔细考虑结果以及提出构建模型的后续步骤的过程，该模型可以预测瓦伦西亚每个 Valenbisi 站的自行车和码头可用性。关于这些的更深入的报道，请继续关注这个博客和我的 Github 上的 Jupyter 笔记本中提供的链接。

收集数据

Nicole 于 2018 年 2 月 16 日请求 Valenbisi 的 API 密钥访问。在发现 API 只提供两年前的数据后，她向我寻求建议。鉴于网站提供了一个实时下载的 CSV 文件，而且当时它的使用条款中也没有禁止抓取，我知道我们可以制作一个抓取器并尝试一下。除了 python 库‘requests’之外，我只用了很少的东西就能构建一个 scraper，并在去西班牙之前的 10 天里，在一个 AWS web 实例上托管它。

这里有一个链接指向我的 Github 托管的 Jupyter 笔记本，在那里我浏览了我在 AWS 上托管的 scraper 的主干。

我每 15 分钟收集实时数据 1001 次。csv 包括“自行车可用”、“加油站空闲”、“总计、 X 和 Y 的信息。

这是 10 天多一点的数据。这使得我们无法观察一年中的季节，而只能观察一周中的季节。由于我们的数据如此之少，这将是一个大规模的例子，可能会更直观地解释。我们将能够关注每周和每小时的趋势。

我们的数据不包括关于哪个活动是重新平衡工作的信息。

我们的数据不包括具体的乘坐数据，这使得这些数据不适合网络分析。

x 和 Y 是 UTF 坐标，可以使用 UTM 图书馆转换成经度和纬度坐标。西班牙的国家代码是“30”和“S”，如下例所示。

[Input]: **import** **utm** utm.to_latlon(725755.944, 4372972.613, 30, 'S')[Output]:
(39.47674728414135, -0.37534073558984327)

并且使用散景，我能够绘制出每个 Valenbisi 站(蓝色)和为第一天安排的主要活动的每个位置(红色)，开始为期一个月的活动:Crida Fallas。2018 年 2 月 25 日。

#Plaza Ayuntamiento @39.4697661，-0.4113992
#圣胡安德尔医院教堂@39.4743981，-0.3814647
#托雷斯·德洛斯·塞拉诺斯@39.4791963，-0.378187

探索性数据分析

首先，我们预计 Crida Fallas 周围的整个系统会出现“尖峰”或一些不规则行为。以下所有车站所有可用自行车的图表显示，还有其他冲击发生，不一定与坠落有关。竖线表示 Crida Fallas，2018 年 2 月 25 日。

We presented to Valencia’s Big Data Meetup. Suggestions for such frequent and unrelated-to-commute-times plummets were system power outages. For this analysis, I retained all datapoints.

接下来，我绘制了三个单独的 Valenbisi 站。也许靠近 Crida Fallas 活动与车站受到的影响有关。首先，我们来看看位于 Crida 活动地点附近或地图上红点附近的车站是什么样的。

Wow, we see a big spike for Crida Fallas, and another later in the week! This station is, as we expected, very close to the city center, the Ayuntamiento. Over all, apparent return to normal behavior after Crida Fallas seems to happen pretty quickly.

对位于市中心附近的车站 Ayuntamiento 的视觉观察。

1. Crida Fallas 期间可用自行车的大高峰
2. 本周晚些时候又一次飙升
3. 总的来说，在 Crida Fallas 之后，相对较快地恢复到“正常”行为

现在，以下车站更靠近巴伦西亚的城市边界。

I see very little recognizable pattern here. Whatever occurred on February 25th looks as if it could have occured any day for this station.

对位于城市西南边界的车站的视觉观察:

1. 这里几乎没有可辨认的图案。
2. 无论这个站在 2 月 25 日表现出什么样的行为，看起来都像是发生在其他任何一天。

位于城市边缘附近的一个站的视觉观察。

1. 没有查一下这个车站附近有什么(也许是医院？)，很明显这里的自行车是用来通勤的。
2. 我们看到，Crida 不仅在当天影响该站，而且在行为恢复“正常”的前一天和后两天也影响该站。

我们看到，无论我们提出什么样的解决方案，都需要适用于具有多种不同行为的电视台。出于我们的目的，让我们对所有数据进行 ARIMA 分析。我选择首先查看所有数据来开始分析，因为它在 Crida Fallas 附近没有表现出不稳定的行为，并且将是 ARIMA 建模的一个很好的学习示例。 ARIMA 模型依赖于这样一种假设，即自行车站点最近所处的州会影响未来可用自行车/码头的数量。此外，ARIMA 模型可以捕捉我们的时间序列数据中的季节关系。

ARIMA 分析

1. 将时间序列分解为趋势、季节性和残差
2. 平稳性检验(迪基-富勒检验)
3. 创建 ARIMA 模型
4. 结果解释

1.分解

视觉观察:

1. 在 10 天的过程中，我们看到了一个略微向上的趋势。这种上升趋势仅涉及 100 辆自行车。
2. 在季节分解中，我们观察到重复。试图解释每个裂缝是徒劳的，但这个特征中的重复模式表明了一种日常行为模式。(我们有 10 天，可以数 10 次重复。)
3. 我们的残差图显示，正如预期的那样:6 次暴跌中只有 5 次出现了重大暴跌，这 6 次暴跌被巴伦西亚 Meetup 观众认为是“可能的断电”。

2.我们的数据是静态的吗？——扩展的迪基-富勒测试

首先，我测试我们的数据是平稳的。重要的是，你的时间序列在预测之前是平稳的，否则你的模型将是一个糟糕的预测器，因为 ARIMA 依赖于平稳性的假设。

An example of non-stationary data, stationized. Provided by https://www.itl.nist.gov/div898/handbook/pmc/section4/pmc442.htm

这可以是它自己的博客帖子，非常有趣。更定量的解释，我推荐这个来源。

出于我们谈话的目的，重要的是要知道，在进行 Dickey-Fuller 检验时，我们是在进行假设检验:

H0:数据是非平稳的

H1:数据是静止的

我使用下面的代码对数据执行 Dickey-Fuller 测试。它是作为我的数据科学训练营的学习练习提供的:

输出:

Our p-value is definitely below .05, meaning we can reject the null hypothesis; our data is stationary!

我们将stats models . TSA . stat tools . ad fuller用于以下输入:

• maxlag : None (因为我们指定 autolag =‘AIC’，所以在我们的例子中不会用到它。)
• 回归:‘c’:仅常量(默认)
• 自动标记:‘AIC’:如果‘AIC’(默认)或‘BIC’，那么选择标记的数量以最小化相应的信息标准。这将选择具有最佳 AIC 分数的模型。

更多关于 AIC 和 BIC 的信息:

AIC 是一个常数加上数据的未知真实似然函数和模型的拟合似然函数之间的相对距离的估计值，因此 AIC 越小，模型越接近真实值。

BIC 是在特定的贝叶斯设置下，对模型为真的后验概率的函数的估计，因此较低的 BIC 意味着模型被认为更有可能是真实的模型。

……尽管存在各种微妙的理论差异，但它们在实践中的唯一区别是处罚的大小；BIC 对模型复杂性的惩罚更重。他们应该不同意的唯一方式是当 AIC 选择一个比 BIC 更大的模型

我们的 Dickey-Fuller 检验的 p 值肯定低于 0.05，这意味着我们可以拒绝零假设。我们的数据是稳定的，因此可以插入 ARIMA 模型。

3.ARIMA 模型

现在开始在这个博客中，你会发现与我们瓦伦西亚大数据会议演示的原始对话有偏差。我希望这篇博客能推动关于方法论的进一步讨论，以及我在 ARIMA 模型和我的数据中遇到的一些不确定性。我对如何提高我的理解和我的模型的谈话和对话持开放态度。

我发现 ARIMA 模型相当不确定，原因如下:

• 在我们的 statsmodels SARIMAX 模型中使用的发现季节性指标的经验方法( ACF/PACF 图)并没有产生一个有效的模型。(详见 github。)
• (在我运行的多个模型中)预测最好的模型是一个几乎没有统计显著滞后变量的模型。

这是我看到的最适合预测的模型的代码。你可以在我的 Github 上找到(几乎)我所有的其他模型。

mod = sm.tsa.statespace.SARIMAX(df[0:960].available, 
                                trend='n', 
                                order=(1,0,1), 
                                seasonal_order=(4,0,7,24), 
                                enforce_stationarity =False, 
                                enforce_invertibility = False)results = mod.fit()
results.summary()

Wow, why does a model with nearly no significant lags produce the best predictions? Perhaps it’s not so bad. Discussion below.

With no other independent variables besides its own behavior, our ARIMA model can predict pretty well, I’d say.

提醒一下:我们只有 10 天的数据，每小时 4 个点的数据。这使得我们无法测试年度季节性关系。出于我们的目的，我打算说一个赛季持续 6 个小时。这意味着每天有四个季节。这应该包括高峰时间、中午和晚上。最直观的是，这使得数据点/季节变量的数量 m = 4*6 = 24。

选择我的(pdq)(PDQ)m 价值观的动机:

非季节性的，对模型当前状态最有影响的滞后是在它之前的滞后期间发生的。p =1，q = 1，(以及 d = 0，因为我们的数据是平稳的)。

p，季节性 AR 订单。我怀疑日期之间有季节性，所以我想看看前一天发生了什么。(24 个数据点的 4 个滞后)

d，季节性差异为 0，因为我们的数据是稳定的。

q，季节移动平均订单。现在我承认，乍一看这似乎是最不直观的。我通过反复试验发现了它，但是如果我们考虑 7 个 24 点的滞后，意味着 42 小时之前，它似乎是可预测性最好的；不到两整天。如果你把一周看成 168 个小时，这些数字会清晰地分开:168/42 = 4。这表明一周有 4 个不同的行为时间。我们希望我们的模型相应地使用 1/4 周作为它的移动平均窗口。

请随意参考我的 github 查看(几乎)我尝试过的所有机型，并在评论中留下任何对机型参数改进的建议。

4.结果解释:

首先，我要承认，虽然存在极少数具有统计显著性的滞后，但移除一个因其 p>|z|值而被认为在统计上无关紧要的变量会对模型的预测能力产生不利影响。 ARIMA(1，0，0)(4，0，7，24)，绿色=预测，蓝色=实际。

An example of what happens when you remove the ma.L1 with p>|z| value .993. ARIMA(1,0,0)(4,0,7,24).

ARIMA(1，0，1)(4，0，7，24)模型确实有整体最低的 AIC 和 BIC 分数*。这些指标不是对模型质量的评分，而是提供了与其他模型进行比较的手段；越低越好。

其次，我想深入了解 Statespace 模型结果提供的一些其他结果:

进行 Ljung-Box (Q) 测试以确认残差是独立的。这意味着我们的误差彼此不相关，我们已经成功地用我们的模型解释了数据中的模式。

我们对 Ljung-Box 进行的假设检验如下:

H0: 数据是独立分布的(即样本总体的相关性为 0，因此数据中任何观察到的相关性都是由抽样过程的随机性造成的)。

H1: 数据不是独立分布的；它们表现出序列相关性。

Ljung-Box(Q)给出的测试统计量遵循 X 分布，具有( h-p-q) 个自由度，其中 h 为测试滞后的数量。

如果 p 值(Prob(Q)) 大于 0.05，那么我们不能拒绝零假设；残差是独立的，这表明模型为数据提供了足够的拟合。我们看到我们的问题(Q)是. 62。太好了。因此，尽管没有很多统计上显著的滞后变量，我们的模型已经设法解释了足够多的方差，即残差是随机的。

**异方差:**线性回归的一个假设是残差不存在异方差。这意味着残差的方差不应随着响应变量的拟合值而增加；我们更喜欢我们的残差是同伦的。

H0: 残差的方差是常数；没有异性。

H1: 异方差存在。

这里我们不能在 95%的置信水平上拒绝零假设，因为我们的 p 值是 0.07。我们可以假设残差中的同质性。好吧，还不错。我们的模型设法通过的另一个测试。

Jarque-Bera 和峰度度量是关于正态性的。我们的数据不是正态分布的，所以现在我将跳过这些度量。

可能的后续步骤

1. 扩大规模，这意味着收集更长时间的数据，并将模型应用于各个站点。考虑一个递归神经网络来模拟时间序列排序。
2. 考虑一个泊松点过程模型来预测可用自行车和码头开放，使用建立时间优先级。shift() 像这样的 DSSG 项目做了。
3. 请求关于再平衡工作的数据。
4. 考虑主要城市活动的特征工程附加变量以及与特定活动的距离。
5. 考虑对受影响的自行车站进行冲击建模。

#数据假期

这是我和妮可为我们的西班牙之行准备的两个演示文稿之一。它被分享给了巴伦西亚数据科学会议。

我们的另一项工作是在巴伦西亚大学商学院的本科生市场营销课上进行的 CRM 数据研讨会。请关注妮可即将发表的关于此事的博客。

数据源:

http://www . Valencia . es/ayuntamiento/datosabiertos . NSF/resultadoCapas/95d 6756 f 6861 f 9 FDC 1257 c 70003 e 4 FBD？open document&lang = 1&nivel = 2&seccion = 1&BD Origen =&idapoyo = 22 ADF 97 C1 FD 223 b5 c 1257 c 55003 BD 01 f

Github 资源库:

[## nmolivo/巴伦西亚-数据-项目

巴伦西亚-数据-项目-数据炸弹

github.com](https://github.com/nmolivo/valencia-data-projects/tree/master/valenbisi)

附加资源:
https://www . data camp . com/courses/introduction-to-time-series-analysis-in-python

理解 AUC - ROC 曲线

原文：https://towardsdatascience.com/understanding-auc-roc-curve-68b2303cc9c5?source=collection_archive---------0-----------------------

Understanding AUC - ROC Curve [Image 1] (Image courtesy: My Photoshopped Collection)

在机器学习中，性能测量是一项基本任务。所以当涉及到分类问题时，我们可以依靠 AUC - ROC 曲线。当我们需要检查或可视化多类分类问题的性能时，我们使用 AUC ( 曲线下的面积 ) ROC ( 接收器操作特性)曲线。它是检验任何分类模型性能的最重要的评价指标之一。也可以写成 AUROC(接收器工作特性下的区域)

注:为了更好的理解，我建议你看一下我写的关于混淆矩阵的文章。

本博客旨在回答以下问题:

1.什么是 AUC - ROC 曲线？

2.定义 AUC 和 ROC 曲线中使用的术语。

3.如何推测模型的性能？

4.敏感性、特异性、FPR 和阈值之间的关系。

5.多类模型如何使用 AUC - ROC 曲线？

什么是 AUC - ROC 曲线？

AUC - ROC 曲线是在各种阈值设置下对分类问题的性能测量。ROC 是概率曲线，AUC 代表可分性的程度或度量。它告诉我们这个模型在多大程度上能够区分不同的类。AUC 越高，模型预测 0 类为 0 和 1 类为 1 的能力越强。以此类推，AUC 越高，模型在区分患病和未患病患者方面就越好。

用 TPR 对 FPR 绘制 ROC 曲线，其中 TPR 在 y 轴上，FPR 在 x 轴上。

AUC - ROC Curve [Image 2] (Image courtesy: My Photoshopped Collection)

定义 AUC 和 ROC 曲线中使用的术语。

TPR(真阳性率)/召回/灵敏度

Image 3

特异性

Image 4

定期用量法(Fixed Period Requirements)

Image 5

如何推测车型的性能？

一个优秀的模型具有接近 1 的 AUC，这意味着它具有良好的可分性度量。差模型的 AUC 接近 0，这意味着它具有最差的可分性度量。事实上，这意味着它在往复结果。它预测 0 是 1，1 是 0。当 AUC 为 0.5 时，这意味着该模型没有任何类别分离能力。

我们来解读一下上面的说法。

我们知道，ROC 是一条概率曲线。让我们画出这些概率的分布:

注:红色分布曲线为阳性类别(患病患者)，绿色分布曲线为阴性类别(未患病患者)。

[Image 6 and 7] (Image courtesy: My Photoshopped Collection)

这是一种理想的情况。当两条曲线完全不重叠时，意味着模型具有理想的可分性度量。它完全能够区分积极类和消极类。

[Image 8 and 9] (Image courtesy: My Photoshopped Collection)

当两个分布重叠时，我们引入类型 1 和类型 2 误差。根据阈值，我们可以最小化或最大化它们。当 AUC 为 0.7 时，这意味着模型有 70%的机会能够区分正类和负类。

[Image 10 and 11] (Image courtesy: My Photoshopped Collection)

这是最坏的情况。当 AUC 约为 0.5 时，该模型没有区分阳性类别和阴性类别的区分能力。

[Image 12 and 13] (Image courtesy: My Photoshopped Collection)

当 AUC 大约为 0 时，模型实际上是在往复类。这意味着模型将一个负类预测为正类，反之亦然。

灵敏度、特异性、FPR 和阈值之间的关系。

灵敏度和特异性是成反比的。所以当我们提高敏感度时，特异性就会降低，反之亦然。

Specificity⬇️的 Sensitivity⬆️和 Specificity⬆️的 Sensitivity⬇️

当我们降低阈值时，我们得到更多的正值，从而增加了灵敏度，降低了特异性。

类似地，当我们增加阈值时，我们得到更多的负值，因此我们得到更高的特异性和更低的敏感性。

正如我们所知，FPR 是 1 -特异性。因此，当我们提高 TPR 时，FPR 也会提高，反之亦然。

FPR⬆️的 TPR⬆️和 FPR⬇️的 TPR⬇️

多类模型如何使用 AUC ROC 曲线？

在一个多类模型中，我们可以使用一个对所有方法为 N 个类绘制 N 个 AUC ROC 曲线。例如，如果您有三个名为 X，Y，和 Z 的类，您将有一个针对 X 和 Z 分类的 ROC，另一个针对 Y 和 Z 分类的 ROC，以及针对 Y 和 X 分类的第三个 ROC

感谢阅读。

我希望我已经让你对什么是 AUC - ROC 曲线有了一些了解。如果你喜欢这篇文章，给这篇文章一些掌声会对你有所帮助👏。我随时欢迎你的问题和建议。你可以在脸书、推特、Linkedin 上分享这个，这样有需要的人可能会偶然发现这个。

您可以通过以下方式联系到我:

领英:https://www.linkedin.com/in/narkhedesarang/

推特:https://twitter.com/narkhede_sarang

github:https://github.com/TheSarang

用 Python 理解基本的机器学习——感知器和人工神经元

原文：https://towardsdatascience.com/understanding-basic-machine-learning-with-python-perceptrons-and-artificial-neurons-dfae8fe61700?source=collection_archive---------4-----------------------

基本功能的完整代码演练

如果你正在学习机器学习，很可能你的目标是应用前沿算法和“深度学习”来创建强大的应用程序。随着直观的 API 的广泛使用，这是可以实现的，只需要对正在发生的事情或深层底层实际上是如何工作的理解很少。

然而，在做这件事之前，浅显的架构基础知识和对底层的洞察是有益的。如果没有这一点，构建偏离盲目跟随教程的模型将变得困难(猴子见猴子做综合症)。

在这篇文章中，我们将讨论人工神经元和分类的起点，包括感知器和 Adaline 模型。对于每个模型，我们将讨论主要组件，然后将它们组合成完整的 Python 类实现。

Image 1. Neuron Cell, taken from Pixabay.

感知器模型

机器学习最根本的起点是人工神经元。第一个简化的脑细胞模型发表于 1943 年，被称为麦卡洛克-皮茨(MCP) 神经元。本质上，这是一个具有二进制输出(“0”或“1”)的基本逻辑门。如果到达神经元的输入的总和超过给定的阈值，则产生“1 ”,其中每个输入乘以相应的权重系数以产生这个总和。因此，神经元的放电很大程度上取决于输入集和相应的权重系数值。

弗兰克·罗森布拉特在 MCP 神经元的基本概念发表后不久就采用了这一概念，并提出了**感知器规则算法。**该允许自动学习神经元模型的最佳权重系数。通过这样的模型，我们可以预测给定的输入是属于一个类还是另一个类(二元分类)。

Figure 1. Simplified Perceptron Model. Diagram by Author.

感知器模型可能有任意数量的输入，也称为特征。因为我们通常有多个特征，所以用向量和矩阵来表示我们的输入和权重是有帮助的。不要混淆输入样本和输入特征；每个数据样本都有许多特征， n，，这些特征通过我们的模型输入，一次处理一个(按顺序)。例如，如果我们有 100 个汽车数据样本，其中每个样本都有 m 个特征(代表最高速度、bhp、成本等)。)，那么数据的每个样本 x 将具有一个 m 个特征的向量。每个输入特征都有一个相应的权重，经过训练后，权重将根据我们训练的数据进行优化。

Figure 2. Vectors for our input features and weights.

对于每个数据样本，我们的输入特征和权重作为一个加权和在感知器中被接受，这就是通常所说的网络输入函数， z *。*对上面的 x 和 w 使用向量的好处是，我们可以使用线性代数来简洁地表示它，就像这样:

Figure 3. Perceptron Net Input Function.

我们转置权重向量 w ，然后与我们的输入向量x相乘，这形成了我们需要的和。还应注意，我们还使用了一个偏差项来允许我们的感知器模型中有一个阈值，它等于我们向量中的第一个权重项。为了方便起见，输入矩阵中的第一个 x 项总是设置为 1。这意味着我们需要在输入向量中加入偏差项，然后再将它放入模型中。

如果你对这种数学符号完全陌生，我强烈推荐一些线性代数入门。几乎你在进一步的机器学习中所涉及的所有内容都将大量基于线性代数。

在净输入求和之后，我们的值被传递给感知器阈值，或决策函数。在这种情况下，该功能是一个单位步进功能。如果输入高于给定值，则输出“1”，否则输出“0”。

那么我们的感知机实际上是如何从一组数据中学习的呢？整个感知器过程如下:

• 将重量参数初始化为初始值(通常是小的随机值，而不是零)。
• 从每个训练样本输入的给定特征预测二进制输出。
• 通过感知器学习规则更新权重。

Figure 4. Model for the Perceptron, including weight optimisation using the error. Diagram by Author.

感知器的成本函数非常简单，被称为**感知器学习规则。**每次训练迭代后，我们的权重向量中的每个权重都会有一个小的变化，如下所示:

Figure 5. Perceptron Learning Rule for updating of weights.

:=符号意味着我们同时更新权重向量中的所有权重，而不是迭代地更新。因此，进行输出预测，然后更新所有权重参数，作为一个训练周期的一部分。上面的 alpha 项也等于学习率，它决定了我们的模型在每个训练周期中学习的速度。

假设我们用于训练的数据是线性可分的，如果经过足够的训练周期(时期)，感知器会将权重更新为最佳值。

Python 中的感知器

我们将从用 Python 编写感知器的每个组件开始，然后在最后将它们组合成一个更大的感知器类。对于这个基本模型，我们唯一需要的 Python 包是 numpy 和 matplotlib 。

抽样资料

为此，我们将生成一个简单的数据集，其中包含两个不同的输出类，供我们的感知器进行训练。注意:该随机训练数据是通过随机函数生成的，并不完全可复制。

为了帮助理解我们正在努力做的事情，可视化我们的数据是有帮助的。在这种情况下，我们的输入样本只有两个特征，因此使用散点图来可视化我们的数据很容易。下面显示了数据生成，然后绘制成散点图。

Figure 6. Sample code for generating bird data and plotting on a scatter graph.

Figure 7. Visualisation of our generated data.

初始权重的生成

我们希望将我们的权重初始化为小的随机数字，而不是将它们初始化为零。我们需要这样做，否则我们的学习率将会降低训练过程中对分类结果的影响。这背后的理由将不被涵盖，然而，这是因为学习率只影响权重向量的规模，而不是方向，如果权重初始化为零。

这些权重可以以不同的方式生成。使用 numpy.random 的一个例子是:

向 X 添加偏差项

对于偏置项，我们只需在输入数据 x 中添加一列 1，在 numpy 中，这可以通过使用one和 hstack numpy 函数来实现。

加权求和函数(净输入)

如上所述，由于我们对每个样本的输入特征及其相关权重使用向量，因此我们可以非常容易地计算净输入和。在 Python 中使用带有 numpy 的矢量化，根据我们是否向训练数据添加了 1 的偏差列，网络输入函数变为:

Figure 8. Implementing the net input sum in numpy.

预测用单位阶跃函数

如果我们的净输入总和大于或等于零，我们希望返回 1，否则返回 0。

Figure 9. Implementing the step input function in numpy.

感知器学习规则

使用之前在图 6 中定义的学习规则，我们可以执行一个完整的训练周期。这包括遍历所有训练样本，并根据感知器学习规则更新权重，如下所示:

Figure 10. Perceptron training cycle implementation.

把所有的放在一起

有了使用 numpy 形成的感知器的基本组件，我们可以将它们拼凑在一起，实现一个完整的感知器二进制分类器。使用分类器，我们可以在训练周期中可视化我们的错误，并且(希望如此！)随着权重的优化，错误数量会随着时间的推移而减少。

Figure 11. Code for a Perceptron class in Python for binary classification.

Figure 12. Visualisation of the errors and decision boundaries made by our Perceptron classifier.

从误差与训练周期(时期)的关系图中可以看出，我们得到的误差数量随着时间的推移而减少。大约 7 个周期后，我们的模型将错误数量减少到零。我们的感知器分类器训练后做出的决策边界如右图所示，有效地区分了金雕和角枭。我们可以通过使用一组新输入 x 调用分类器预测函数，使用我们训练的模型对新数据进行预测。

感知器的一个问题是，如果所提供的数据是完全线性可分的，它们只会正确地优化权重。对于上面使用的数据，它是线性可分的。然而，如果我们使用更现实的数据，这些数据通常不能用直线分开，那么我们的感知器分类器将永远不会停止优化权重，并将不断出现错误。这是一个巨大的缺点，也是不使用感知机的原因之一。然而，它们确实是对基本神经元和更复杂模型的良好介绍。

Adaline——自适应线性神经元

对原始感知器模型的改进是 Adaline，它增加了一个用于优化权重的线性激活函数。通过这种添加，使用连续成本函数而不是单位步长。Adaline 很重要，因为它为更高级的机器学习模型奠定了基础。

Figure 13. Model for Adaline, which includes the additional activation function. Diagram by Author.

正如您在上面看到的，单位步骤仍然存在，但是它仅用于模型末尾的输出分类(“1”或“0”)。线性激活模型的连续输出值用于成本(或目标)函数。这表明我们的算法在我们的训练数据上做得有多差(或多好)，并且可以通过众所周知的算法(如梯度下降)将其最小化。

价值函数

在这种情况下，我们将使用误差平方和作为我们的成本函数，可以这样实现:

Figure 14. Sum of Squared Errors implementation in Python.

梯度下降

为了应用梯度下降，我们需要确定成本函数相对于每个权重的偏导数。利用微分，我们发现这个偏导数等于:

Figure 15. Partial derivative of our cost function with respect to each weight.

为了优化我们的权重，我们希望以我们的学习速率参数所选择的速率，在梯度的相反方向上迈出一步。这背后的逻辑是最小化成本并最终达到全局最小值。因此，对于每次重量优化，我们需要应用:

Figure 16. Optimisation updates for our weights in the Adaline model.

我们可以将权重优化步骤和成本计算步骤合并到一个训练周期代码片段中，如下所示:

Figure 17. One training cycle for our Adaline model.

特征标准化

除了激活功能和梯度下降优化，我们还将通过 F 功能标准化增强我们模型的性能。这是机器学习中的一种常见做法，对于给定数量的时期，这种做法使优化过程更快、更有效。为此，我们将从训练数据中的每个相关特征值中减去每个特征的平均值，然后将特征值除以它们各自的标准偏差。

Figure 18. Feature standardisation in Python.

把所有的放在一起

有了 Adaline 模型的附加组件，我们就可以用 Python 生成一个最终的实现，就像我们用感知器一样。这个 Adaline 实现如下所示:

Figure 19. Adaline Classifier implemented in Python.

从下图中的基本 Adaline 示例中，我们可以看到为我们的模型设置超参数是多么重要；如果我们选择 0.1 的学习率，成本趋于无穷大并且不收敛，而如果我们选择 0.001 的学习率，我们的模型成功地收敛到成本函数的全局最小值。迭代的次数也很重要，应该足够高以充分降低成本。机器学习模型的这些可调方面被称为超参数，这些优化对于我们创建的任何模型都是一个重要方面。

Figure 20. Comparison of different choices of learning rate for our Adaline classifier.

进一步改进和结束语

有很多方法可以进一步改进这个模型，包括随机梯度下降，它可以更频繁地优化，而不是像上述模型那样使用整批训练数据。我们还可以将它扩展到不仅仅是二元分类，使用一元对多元分类。

此外，还有比 Adaline 好得多的分类器可用。Adaline 是一个起点，可以用作理解更复杂的分类模型(如逻辑回归和神经网络)的基础。

在这篇文章中，我们研究了基本神经元的特性，然后使用 Python 和 numpy 构建了一个基本的 Rosenblatt 感知器模型。然后，我们构建了一个工作 Adaline 分类器，它通过激活函数和优化成本函数，在许多方面改进了感知器。在此期间，我们还应用了一些有价值的特征处理，包括标准化以使梯度下降更快更有效。

虽然这些模型不能替代通过 Sci-kit Learn 和其他软件包获得的专业构建和优化的模型，但它们应该能够让人们了解基本分类器的工作原理。我希望我们遵循的过程有助于您理解基本的机器学习分类，并为您提供使用 Python 实现这些模型的洞察力。

通过超级马里奥了解机器学习的基础

原文：https://towardsdatascience.com/understanding-basics-of-machine-learning-through-super-mario-5ed93c7d587d?source=collection_archive---------3-----------------------

Super Mario Land for gameboy

有很多关于神经网络和机器学习的文章，因为这个主题在过去几年里非常受欢迎。这个领域似乎非常难以接近和理解，许多人可能认为必须是数学家或统计学家才能掌握机器学习的概念。然而，机器学习和神经网络的基本概念不一定像人们想象的那样复杂。

本文的目的是通过一个任何人都能理解的简单例子来解释机器学习如何工作的高级概念。希望它能给你兴趣和信心，让你继续阅读和学习更多关于这个主题的知识，打破让它看起来如此不可接近的令人生畏的障碍。

强化学习

机器学习程序与常规程序的不同之处在于，程序员没有明确定义逻辑。程序员创造了一个程序，它有能力自学如何成功地完成手头的任务。我要举的例子很可能会被认为是一个强化学习的机器学习程序。这个程序接受输入，做出自己的决定并产生一个输出，然后从输出产生的回报中学习，一遍又一遍地重复整个过程。这听起来可能很抽象，但这和我们人类学习如何做事的方式非常相似。下面我将把它分解成人类能够理解的步骤。还有什么比超级马里奥更好的表达方式呢？

要开始我们的思维实验，你必须想象你对电脑游戏完全陌生。你甚至从未听说过它们，更不用说以前玩过了。然后有人给你一个超级马里奥的游戏。

投入

你看着屏幕，看到简单的 2D 风景。这被认为是您的输入；你开始看这个小图形，这是马里奥，然后是风景中的所有其他物体。

输出

你有四种可能的方式与游戏互动。你可以左，右，蹲，跳。这些是你的输出。您可以根据输入来决定应该选择哪个输出。

报酬

你目前不知道游戏中有什么潜在的奖励，但是很快你就会亲身体验到。每个输出的奖励在游戏中会有所不同。如果你只是向左或向右走，回报是相当低的。如果你走进一枚硬币，奖励会稍微高一点。如果你跳进一个神秘的盒子，奖励会更高。然而，如果你被敌人击中，你的奖励是负的——不用说，负奖励更像是一种惩罚。

你学习如何玩超级马里奥

完全新手如何玩游戏，你开始按下右箭头。马里奥向右移动，你会得到奖励。然而，当你继续按右箭头时，马里奥最终击中了一个古姆巴，在这个古姆巴上你得到了死亡的奖励！

Mario got rewarded by death for hitting the Goomba

别担心，你可以重新开始。这一次，当你记录向你走来的古姆巴的输入时，你尝试其他的输出来获得不同的回报。经过几次尝试后，你意识到在那次遭遇中获得最高奖励的输出是跳到古姆巴上面，或者跳过它。你现在开始学习如何玩超级马里奥。

Mario is rewarded by staying alive for jumping over the Goomba

这就是强化学习的概念在现实生活中的工作方式。机器学习程序一开始是一张白纸，对它应该做的任务一无所知。然后，它接受一个输入，即它所处的环境，并开始试图找出哪个输出给它最高的回报。这个概念非常符合人类如何通过试错来学习做新的事情。我们尝试一种方式，然后是不同的方式，直到我们得到我们想要或期望的回报。

但是每个人都已经知道如何玩超级马里奥了…

的确，没有人真的需要学习如何玩超级马里奥，因为它是一个非常直观的游戏。甚至小孩子也能成功地玩这个游戏。

这样做的原因是，我们在游戏中加入了以前的经验，因此可以更好地掌握游戏规则，更快地获得更高的奖励。在机器学习中，这将被视为训练。

培养

如前所述，每当机器学习程序开始试图找出如何成功完成一项任务时，它都会从头开始。因此，给程序一些训练数据是很重要的，这样它就有了一些开始的基础，这样它就不会一遍又一遍地犯小错误，直到它最终知道任务是什么。

当然，如果有足够的时间，机器学习算法将能够训练自己成功完成给定的任务。这可能需要很长时间，因此为您的程序提供高质量的训练数据以获得更准确的结果是非常重要的。

结论

他们从这篇阅读中得到的关键是理解机器学习算法如何比程序性程序更类似于人类如何学习完成任务。在过程程序中，决策是通过条件语句硬编码到程序中的。例如，这将是程序员识别超级马里奥游戏中的威胁，并输入如下语句:如果检测到威胁，则执行该特定动作，否则继续执行。这种过程方法和机器学习方法之间的主要区别是，最终，计算机程序有自主权做出自己的决定。理解这一点很重要，因为机器学习程序可以用于其他类似的任务，而不必重新编程。我们的示例程序可以在学习玩超级马里奥后很好地学习如何玩任何其他游戏，并且成功率很高，并且玩的游戏越多，玩的游戏越好。这种行为非常类似于一个人在玩不同的游戏时会变得越来越好，尽管每个游戏并不完全相同。我们利用以前的经验学得更快。

这篇文章只是对一个更深入的主题的一个非常简短的概述。如果你对深入研究人工智能和机器学习感兴趣，我会推荐这个文章系列。

如果你喜欢这篇文章，请鼓掌和评论！

使用交互代码的 Numpy 和 Tensorflow 中的示例了解批处理规范化

原文：https://towardsdatascience.com/understanding-batch-normalization-with-examples-in-numpy-and-tensorflow-with-interactive-code-7f59bb126642?source=collection_archive---------1-----------------------

Gif from here

所以今天我就来探讨一下批量规格化( 批量规格化:通过减少内部协变 ShiftbySergey io FFE，以及Christian Szegedy)。然而，为了加强我对数据预处理的理解，我将讨论 3 种情况，

案例 1 — 归一化:全数据(Numpy)
案例 2 — 标准化:全数据(Numpy)
案例 3 — 批量归一化:小批量(Numpy / Tensorflow)

注 本帖不涉及反向传播！

实验设置

这个实验的设置非常简单。为了模拟真实世界的用例，让我们从随机正态分布创建一个 32*32 的图像，并添加一些噪声。以上是我们的形象看起来像。

红框 →(图像数量，图像宽度，图像高度，通道数量)现在我们将使用 32*32 灰度图像。
左图 →我们图像数据的直方图

正如你在上面看到的，我们的图像平均值为 26，方差为 306。在左边，我们可以看到图像数据的直方图。

情况 1:归一化—全部数据

对于我们的第一个例子，让我们对整个数据集进行归一化。视觉上我们看不出有什么不同。

然而，一旦我们绘制直方图或查看平均值和标准差，我们可以清楚地看到我们的数据在 0 和 1 的范围内。

案例 2:标准化—全部数据

同样，视觉上我看不出彼此有什么太大的不同。

然而，当我们看到直方图的轴时，我们可以清楚地看到，我们的数据的平均值已经移动到 0(几乎)，方差为 1。

标准化/规范化方程

Image from this website

左→ 标准化方程
右 →标准化方程

以防万一，如果有人想知道，让我们回顾一下标准化和规范化两种情况下的等式。请注意 μ 是平均值， σ 是标准差。

批量归一化方程

红框→ 标准化方程
蓝线→ 将要学习的参数

现在我们已经讨论了标准化和规范化，我们可以看到，批量标准化的等式与规范化的过程完全相同。唯一的区别是伽玛和贝塔项，用蓝色下划线标出。我们可以将这些项想象成权重，我们将从地面真实数据中计算误差，并使用反向传播来学习这些参数。

但是有一点我希望注意！如果我们把 gamma(谢谢 洛阳方 纠正我 ) 设为 1，beta 设为 0 整个过程只是标准化而已。对于 Tensorflow 的实现，我们将滥用该属性。

案例三:批量归一化——纯实现

红线 →小批量，从我们的图像数据
中取出前 10 张图像，蓝框 →数据标准化

这里有一点需要注意，对于批量标准化，我们将从测试数据中提取前 10 幅图像，并应用批量标准化。

同样，我们可以看到均值在 0 左右，方差为 1。现在让我们看看 tensorflow 的实现。

案例三:批量归一化—张量流

红线 → Mini Batch，来自我们图像数据
的前 10 张图像蓝线→ Offset (Beta)为 0，Scale (Gamma)为 1

还是那句话，视觉上，我们看不出任何区别。

但是，如果我们看一下数据的平均值和方差，我们可以看到这与应用标准化完全相同。

交互代码(谷歌 Collab/ Replit/微软 Azure 笔记本)

对于谷歌 Colab，你需要一个谷歌帐户来查看代码，而且你不能在谷歌 Colab 中运行只读脚本，所以在你的操场上做一个副本。最后，我永远不会请求允许访问你在 Google Drive 上的文件，仅供参考。编码快乐！

要访问 Google Colab 上的代码，请点击此处。
要访问 Repl it 上的代码，请点击这里。
要访问 Microsoft Azure 笔记本上的代码，请单击此处。

遗言

最近 Face book AI 研究组发布了群组规范化。( 分组规格化n by吴雨欣 ，以及 明凯何 )我会尽量涵盖这一点。

如果发现任何错误，请发电子邮件到 jae.duk.seo@gmail.com 给我，如果你想看我所有写作的列表，请在这里查看我的网站。

同时，在我的 twitter 这里关注我，并访问我的网站，或我的 Youtube 频道了解更多内容。如果你感兴趣，我还在这里做了解耦神经网络的比较。

参考

1. CS231n 冬季:第五讲:神经网络第二部分。(2018).YouTube。检索于 2018 年 3 月 19 日，来自https://www.youtube.com/watch?v=gYpoJMlgyXA&feature = youtu . be&list = plkt 2 usq 6 rbvctenobvg 1 tpcc 7 aoqi 31 ALC&t = 3078
2. thorey，C. (2016 年)。流过批量归一化的渐变是什么样子的？。cthorey . github . io . 2018 年 3 月 19 日检索，来自http://cthorey.github.io/backpropagation/
3. 推导批量范数反投影方程。(2018).chrisyeh 96 . github . io . 2018 年 3 月 19 日检索，来自https://chrisyeh 96 . github . io/2017/08/28/derivating-batch norm-back prop . html
4. 推导批次标准化的后向传递的梯度。(2018).kevinzakka . github . io . 2018 年 3 月 19 日检索，来自https://kevinzakka . github . io/2016/09/14/batch _ normalization/
5. 克拉泽特，F. (2018)。了解反向传递批处理规范化层。krat zert . github . io . 2018 年 3 月 19 日检索，来自https://krat zert . github . io/2016/02/12/understanding-the gradient-flow-through-the-batch-normalization-layer . html
6. (2018).Arxiv.org。检索于 2018 年 3 月 19 日，来自https://arxiv.org/pdf/1502.03167.pdf
7. NumPy . histogram—NumPy 1.13 版手册。(2018).Docs.scipy.org。检索于 2018 年 3 月 19 日，来自https://docs . scipy . org/doc/numpy-1 . 13 . 0/reference/generated/numpy . histogram . html
8. NumPy . random . Weibull—NumPy v 1.13 手册。(2018).Docs.scipy.org。检索于 2018 年 3 月 19 日，来自https://docs . scipy . org/doc/numpy-1 . 13 . 0/reference/generated/numpy . random . Weibull . html # numpy . random . Weibull
9. numpy.var — NumPy v1.14 手册。(2018).Docs.scipy.org。检索于 2018 年 3 月 26 日，来自https://docs . scipy . org/doc/numpy/reference/generated/numpy . var . html
10. 数据？，H. (2018)。如何用 Python 中的 Matplotlib 绘制一个带有数据列表的直方图？。Stackoverflow.com。检索于 2018 年 3 月 26 日，来自https://stack overflow . com/questions/33203645/how-to-plot-a-histogram-using-matplotlib-in-python-with-a-list-of-data
11. numpy.random.randn — NumPy v1.14 手册。(2018).Docs.scipy.org。检索于 2018 年 3 月 27 日，来自https://docs . scipy . org/doc/numpy/reference/generated/numpy . random . randn . html
12. 吴，杨，何，王(2018)。群体规范化。Arxiv.org。检索于 2018 年 3 月 27 日，来自 https://arxiv.org/abs/1803.08494
13. 标准化与规范化|数据挖掘博客—【www.dataminingblog.com 。(2007).Dataminingblog.com。检索于 2018 年 3 月 27 日，来自http://www . dataminingblog . com/standardization-vs-normalization/
14. 约夫和塞格迪(2015 年)。批量标准化:通过减少内部协变量转移加速深度网络训练。Arxiv.org。检索于 2018 年 3 月 27 日，来自https://arxiv.org/abs/1502.03167
15. 正态分布。(2018).Mathsisfun.com。检索于 2018 年 3 月 27 日，来自https://www . mathsisfun . com/data/standard-normal-distribution . html

理解 PyTorch 中的双向 RNN

原文：https://towardsdatascience.com/understanding-bidirectional-rnn-in-pytorch-5bd25a5dd66?source=collection_archive---------2-----------------------

快速回顾

Fig 1: General Structure of Bidirectional Recurrent Neural Networks. Source: colah’s blog

双向递归神经网络(RNN)实际上只是将两个独立的递归神经网络放在一起。对于一个网络，输入序列以正常的时间顺序馈送，而对于另一个网络，输入序列以相反的时间顺序馈送。两个网络的输出通常在每个时间步被连接，尽管还有其他选择，例如求和。

这种结构允许网络在每个时间步都具有关于序列的前向和后向信息。这个概念似乎很简单。但是当实际实现一个利用双向结构的神经网络时，就出现了混淆…

困惑

第一个困惑是关于将双向 RNN 的输出转发到密集神经网络的方式。对于普通的 RNNs，我们可以只转发最后一个时间步的输出，下面的图片是我通过谷歌找到的，展示了双向 RNN 的类似技术。

Fig 2: A confusing formulation. Image Source

但是等等…如果我们选择最后一个时间步的输出，反向 RNN 只会看到最后一个输入(图中的 x_3)。它几乎不会提供任何预测能力。

第二个困惑是关于返回隐藏状态。在 seq2seq 模型中，我们需要编码器的隐藏状态来初始化解码器的隐藏状态。直观地说，如果我们只能在一个时间步选择隐藏状态(如 PyTorch ),我们会选择 RNN 刚刚消耗完序列中最后一个输入的状态。但是如果返回时间步长 n (最后一个)的隐藏状态，和以前一样，我们将得到反转 RNN 的隐藏状态，只看到一步输入。

查看 Keras 实现

Keras 为双向 rnn 提供了一个包装器。如果您查看 wrappers.py 中的第 292 行:

[## fchollet/keras

用于 Python 的深度学习库。在 TensorFlow、Theano 或 CNTK 上运行。

github.com](https://github.com/fchollet/keras/blob/4edd0379e14c7b502b3c81c95c7319b5df2af65c/keras/layers/wrappers.py#L292)

你会发现，默认情况下，反向 RNN 的输出按时间步长向后排序( n…1 )。当return_sequences为真(默认为假)时，Keras 将反转它。因此，如果我们采用一个时间步长输出，Keras 将在正常 RNN 的时间步长 n 采用一个，在反向 RNN 的时间步长 1 采用一个。这很好地证实了图 2 显示了有缺陷的结构。

在 PyTorch 中它是如何工作的

随着第一个困惑的解决。我们现在感兴趣的是如何在 PyTorch 中正确使用双向 rnn:

上面的笔记本回答了我们遇到的两个困惑(假设batch_first为假):

1. 我们要取output[-1, :, :hidden_size](正常的 RNN)和output[0, :, hidden_size:](反向的 RNN)，把它们串联起来，把结果反馈给后续的密集神经网络。
2. 返回的隐藏状态是消耗完整个序列后的状态。它们可以被安全地传递给解码器。

(边注)batch_first为假时 PyTorch 中 GRU 的输出形状:

输出(序列长度，批次，隐藏尺寸*数量方向)

h_n (层数*方向数，批次，隐藏大小)

LSTM 的方法类似，但是返回一个附加的单元格状态变量，形状与 h_n. 相同

理解二元交叉熵/对数损失:一个直观的解释

原文：https://towardsdatascience.com/understanding-binary-cross-entropy-log-loss-a-visual-explanation-a3ac6025181a?source=collection_archive---------0-----------------------

Photo by G. Crescoli on Unsplash

介绍

如果你正在训练一个二进制分类器，很可能你正在使用二进制交叉熵 / 对数损失作为你的损失函数。

有没有想过用这个损失函数到底是什么意思？问题是，考虑到今天的库和框架的易用性，很容易忽略所使用的损失函数的真正含义。

动机

我在寻找一篇博客文章，以一种视觉上清晰简洁的方式解释二元交叉熵 / 日志损失背后的概念，这样我就可以在数据科学务虚会上向我的学生展示它。因为我找不到任何适合我的目的的，所以我自己承担了写它的任务:-)

一个简单的分类问题

让我们从 10 个随机点开始:

x = [-2.2, -1.4, -0.8, 0.2, 0.4, 0.8, 1.2, 2.2, 2.9, 4.6]

这是我们唯一的特色 : x 。

Figure 0: the feature

现在，让我们给我们的点分配一些颜色:红色和绿色。这些是我们的标签。

Figure 1: the data

所以，我们的分类问题非常简单:给定我们的特征x，我们需要预测它的标签** : 红色或者绿色。**

既然这是一个二元分类，我们也可以把这个问题提出来:“点是绿色的”或者更好一点，“点是绿色的的概率是多少”？理想情况下，绿点的概率为 1.0 (绿色)，而红点的概率为 0.0 (绿色)。

在此设置中，绿点属于正类 ( 是，为绿色)，而红点属于负类 ( 否，为非绿色)。

如果我们拟合一个模型来执行这个分类，它将预测我们每一个点都是绿色的概率。给定我们所知道的点的颜色，我们如何评估预测的概率有多好(或多差)？这就是损失函数的全部目的！对于不良预测，它应该返回高值，对于良好预测，它应该返回低值。

对于像我们的例子一样的二元分类，典型的损失函数是二元交叉熵 / 对数损失。

损失函数:二元交叉熵/对数损失

如果你查找这个损失函数，你会发现:

Binary Cross-Entropy / Log Loss

其中 y 为的标号(对于 绿色点为 1 ，对于 红色点为0****)p(y)为所有 N 点为绿色的预测概率。

阅读这个公式，它告诉你，对于每一个绿色点( y=1 )，它将 log(p(y)) 加到损失上，即它是绿色的的 log 概率。反之，它为每个红色点( y=0 )加上 log(1-p(y)) ，即它为红色的 log 概率。当然，不一定很难，但也没有那么直观…

况且熵跟这一切有什么关系？为什么我们首先采用概率对数？这些都是有效的问题，我希望在下面的“展示数学”部分回答它们。

但是，在进入更多公式之前，让我给你看一个上面公式的可视化表示…

计算损失——可视化方法

首先，让我们将分门别类，正或负，如下图:

Figure 2: splitting the data!

现在，让我们训练一个逻辑回归来对我们的点进行分类。拟合回归是一条s 形曲线，代表对于任何给定的x点为绿色的概率。看起来是这样的:

Figure 3: fitting a Logistic Regression

那么，对于所有属于正类 ( 绿)的点，我们的分类器给出的预测概率是多少？这些是下的绿色条s 形曲线，在 x 坐标处对应的点。

Figure 4: probabilities of classifying points in the POSITIVE class correctly

好的，到目前为止，一切顺利！负类中的点呢？记住， 下的绿色条s 形曲线代表给定点为绿色的概率。那么，给定点红的概率是多少？上方的**红色条s 形曲线*，当然:-)***

Figure 5: probabilities of classifying points in the NEGATIVE class correctly

将所有这些放在一起，我们最终会得到这样的结果:

Figure 6: all probabilities put together!

条形代表与每个点的相应真实类别相关的预测概率！

好了，我们有了预测的概率…是时候通过计算二元交叉熵* / 日志损失来评估**了！*

这些概率就是我们所需要的全部，所以，让我们去掉 x 轴并使棒条彼此相邻:

Figure 7: probabilities of all points

嗯，挂杆已经没有多大意义了，所以让我们重新定位它们:

Figure 8: probabilities of all points — much better 😃

因为我们试图计算一个损失，我们需要惩罚坏的预测，对吗？如果真类关联的概率为 1.0 ，我们需要它的损失为零。反之，如果那个概率是 低，比如说 0.01 ，我们需要它的损失是巨大！

事实证明，采用概率的*(负)对数非常适合我们的目的(由于 0.0 和 1.0 之间的值的对数是负的，我们采用负对数来获得损失的正值)。***

实际上，我们使用 log 的原因来自于交叉熵的定义，请查看下面的“展示数学”部分了解更多细节。

下面的图给了我们一个清晰的画面——随着真实等级的预测概率变得更接近零，损失呈指数增长:

Figure 9: Log Loss for different probabilities

很公平！让我们取概率的(负)对数——这些是每个点对应的损失。

最后，我们计算所有这些损失的平均值。

Figure 10: finally, the loss!

瞧！我们已经成功计算出这个玩具例子的二元交叉熵 / 对数损失。是 0.3329！

给我看看代码

如果您想再次检查我们找到的值，只需运行下面的代码并自己查看:-)

给我看看数学(真的？！)

玩笑归玩笑，这篇文章不是旨在非常数学化…但是对于那些想要理解熵、对数在所有这些中的作用的读者，我们开始吧:-)

如果你想更深入地了解信息论，包括所有这些概念——熵、交叉熵以及更多更多——请查看克里斯·奥拉的 帖子 查看，它非常详细！

分配

先说我们的积分分布。由于 y 代表我们点的类(我们有 3 个红点和 7 个绿点，这就是它的分布，姑且称之为 q(y) ，看起来像是:

Figure 11: q(y), the distribution of our points

熵

熵是与给定分布 q(y) 相关的不确定性的度量。

如果我们所有的点都是绿色会怎么样？的不确定性会是什么样的分布？零对吧？毕竟，一个点的颜色是毫无疑问的:它总是绿色！所以，熵为零！

另一方面，如果我们确切地知道一半的点是绿色而的另一半是、红色会怎么样？这是最糟糕的情况，对吗？我们在猜测一个点的颜色上绝对没有优势:这完全是随机的！在这种情况下，熵由下面的公式给出(我们有两类(颜色)——红色或绿色——因此， 2 ):

Entropy for a half-half distribution

对于在之间的每隔一种情况，我们可以计算分布的熵，就像我们的 q(y) 一样，使用下面的公式，其中 C 是类的数量:

Entropy

所以，如果我们知道一个随机变量的真实分布，我们就可以计算出它的熵。但是，如果是这样的话，为什么首先要费心训练一个分类器？毕竟，我们知道真实的分布…

但是，如果我们不呢？我们能否尝试用一些其他分布来近似真实分布，比如说 p(y) ？我们当然可以！:-)

交叉熵

让我们假设我们的分 跟随这个其他分布 p(y) 。但是我们知道他们是从真 ( 未知)分布 q(y) 实际上来的对吧？

如果我们像这样计算熵，我们实际上是在计算两个分布之间的交叉熵:

Cross-Entropy

如果我们奇迹般地将与* p(y) 到 q(y) 完美匹配，那么交叉熵 和 熵 的计算值也将与匹配。*

因为这很可能永远不会发生，交叉熵的值将大于对真实分布计算的熵。

Cross-Entropy minus Entropy

原来，交叉熵和熵之间的差异有一个名字…

库尔贝克-莱布勒散度

Kullback-Leibler 散度，或简称为“ KL 散度 ，是两个分布之间相异度的度量:

KL Divergence

这意味着，p(y)越接近 q(y) ，越低，散度，因此，交叉熵，将是。

所以，我们需要找一个好的 p(y) 来用……但是，这是我们分类器应该做的，不是吗？！的确如此！它寻找最可能的 p(y) ，也就是最小化交叉熵的那个。

损失函数

在其训练期间，分类器使用其训练集中的 N 个点中的每一个来计算交叉熵损失，有效地拟合分布 p(y) ！由于每个点的概率是 1/N，交叉熵由下式给出:

Cross-Entropy —point by point

还记得上面的图 6 到 10 吗？我们需要在与每个点的真实类别相关联的概率之上计算交叉熵。这意味着使用绿色条用于正级 ( y=1 )中的点，使用红色悬挂条用于负级 级 ( y=0 )中的点，或者从数学上来说:**

Mathematical expression corresponding to Figure 10 😃

最后一步是计算两个类别中所有点的平均值，正值和负值:

Binary Cross-Entropy — computed over positive and negative classes

最后，通过一点点操作，我们可以从正类或负类中取任意一点，在相同的公式下:

Binary Cross-Entropy — the usual formula

瞧吧！我们回到了原始公式用于二元交叉熵/对数损失 😃

最后的想法

我真心希望这篇文章能够在一个经常被认为是理所当然的概念上闪耀一些新的光芒，这个概念就是二元交叉熵作为损失函数。此外，我也希望它能向你展示一点点机器学习和信息论是如何联系在一起的。

2022 年 7 月 10 日更新:我刚刚在 YouTube 上发布了一个视频，里面有这篇文章的动画版本——来看看吧！

Understanding Binary Cross-Entropy / Log Loss in 5 Minutes!

如果你有什么想法、意见或问题，欢迎在下方留言评论或联系我 推特 。

如何理解您的聚类结果

原文：https://towardsdatascience.com/understanding-clustering-cf0117148ef4?source=collection_archive---------3-----------------------

我正与全球许多客户合作实施各种数据科学项目。有时，客户希望进行群集，而我试图避免这种情况。我遵循一个简单的经验法则:

如果你能被监督，那就去被监督。

原因很简单。每个分析都有超参数。这些都需要确定。在有监督的情况下，优化什么是相当直接的:商业价值。在无人监督的情况下，你常常很难找到正确的衡量标准。当然，有很多方法可以衡量你的聚类质量，比如戴维斯-波尔丁指数或者轮廓系数。但是它们与我的业务目标不一致，因此不好。

原来很多分割问题都可以转化为分类问题。这样做总是更可取的。只有在极少数情况下你不能。在这种情况下，您需要使结果易于理解，以符合您的业务目标。以下是我让聚类结果易于解释的技巧。

技巧 1——把它变成一个特征选择问题

通常在数据分析中，您需要能够将业务问题映射到方法。在您的案例中，问题是:*什么最能描述 cluster_0？*或者换句话说:【cluster _ 0 与其他所有产品的区别是什么？这其实可以解释为一个特征选择问题。您想知道哪些特征具有区分聚类的能力。我建议以一对一的方式来做这件事，因为这回答了直接的问题。

Data on two dimensions grouped. A feature selection technique would identify that both dimensions are important to distinguish the classes.

通常的特征选择技术，如包装器或过滤器方法，提供了一系列特征及其重要性。那已经相当不错了！

在众所周知的泰坦尼克号数据集上，我们可以得到“年龄、性别和乘客级别”作为最重要的属性。这使得我们可以将 cluster_0 重命名为:“年龄-性别-乘客级别”。这里的问题是，虽然你发现了重要的因素，但你没有指明方向。这是一群老人吗？或者说是年轻女性？我们可以通过查看质心坐标来更深入地挖掘，并将它们放入透视图中。但是有一个更简单的方法:决策树！

诀窍 2——决策树！

决策树是最容易理解的机器学习模型之一。通常它们用于解决分类问题。我们将使用它们来首先区分我们的 cluster_0 和所有其他聚类。

The Decision Tree can distinguish between the classes and also tell you on the exact values to look at.

第二步是分析决策树分支。所有预测我们的 cluster_0 的分支都可以作为描述。我们可以得到像这样的分支:

年龄< 20，乘客阶级=第一，性别=女。

这很好地描述了我们 cluster_0！

你也可以看看我们的描述有多精确，通过看树的训练精度。你需要平衡结果的质量和可解释性。您可以通过使用修剪来实现这一点。我建议在树的深处进行硬切割。根据我的经验，最多 4 到 5 次就能得到好的结果。人类经常高估他们解释模型的能力。对于决策树，他们通常把所有割的重要性等同起来，而他们需要在上下文和层次结构中进行解释。

理解编译器——面向人类(第 2 版)

原文：https://towardsdatascience.com/understanding-compilers-for-humans-version-2-157f0edb02dd?source=collection_archive---------6-----------------------

编程语言如何工作

从内部理解你的编译器可以让你有效地使用它。在这个按时间顺序排列的大纲中，浏览编程语言和编译器是如何工作的。许多链接、示例代码和图表有助于您的理解。

作者说明

*理解编译器——人类版(第 2 版)*是我第二篇关于 Medium 的文章的后续，有超过 21，000 的浏览量。我很高兴我能对人们的教育产生积极的影响，并且我很高兴能根据我从最初的文章中得到的信息给带来一个完整的重写。

[## 理解编译器——为了人类

你是否点击了绿色的运行按钮，但并不真正知道引擎下面发生了什么？你想知道一个…

medium.com](https://medium.com/@CanHasCommunism/understanding-compilers-for-humans-ba970e045877)

我选择了铁锈作为这部作品的主要语言。它冗长、高效、现代，而且从设计上看，对于编译器来说非常简单。我喜欢使用它。【https://www.rust-lang.org/

这篇文章的目的是保持读者的注意力，而不是有 20 页令人麻木的阅读。文本中有许多链接，将引导您找到更深入了解您感兴趣的主题的资源。大多数链接会将你引向维基百科。

欢迎在底部的评论区提出任何问题或建议。感谢您的关注，希望您喜欢。

介绍

什么是编译器

总之，你所谓的编程语言实际上只是一种叫做编译器的软件，它可以读取文本文件，对其进行大量处理，并生成二进制文件。由于计算机只能读取 1 和 0，而人类比二进制写得更好，编译器被设计成将人类可读的文本转换成计算机可读的机器码。

编译器可以是将一种文本翻译成另一种文本的任何程序。例如，这里有一个用 Rust 编写的编译器，它把 0 变成 1，把 1 变成 0:

While this compiler doesn’t read a file, doesn’t generate an AST, and doesn’t produce binary, it is still considered a compiler for the simple reason that it translates an input.

编译器做什么

简而言之，编译器获取源代码并生成二进制代码。因为从复杂的、人类可读的代码直接转换成 1 和 0 是相当复杂的，所以编译器在程序运行之前有几个处理步骤要做:

1. 读取你给它的源代码的单个字符。
2. 将字符分类为单词、数字、符号和运算符。
3. 获取排序后的字符，通过将它们与模式进行匹配来确定它们试图执行的操作，并生成操作树。
4. 迭代上一步中在树中进行的每个操作，并生成等效的二进制文件。

虽然我说编译器立即从操作树进入二进制，但它实际上生成汇编代码，然后汇编/编译成二进制。汇编就像一个更高级的、人类可读的二进制文件。更多了解什么是 这里是 。

什么是口译员

解释器很像编译器，因为它们阅读并处理语言。不过，解释器跳过代码生成，执行 AST 实时 。对解释器来说，最大的好处是在调试期间开始运行程序所花费的时间。编译器在程序执行前可能要花几秒到几分钟的时间来编译程序，而解释器不编译就立即开始执行。解释器最大的缺点是它需要安装在用户的计算机上，然后程序才能执行。

本文主要指的是编译器，但是应该清楚它们之间的区别以及编译器之间的关系。

1.词汇分析

第一步是一个字符一个字符地分割输入。这一步被称为词法分析，或标记化。主要的想法是，我们将字符组合在一起，形成我们的单词、标识符、符号等等。词法分析大多不处理像求解2+2这样的逻辑问题——它只会说有三个记号:一个数字:2，一个加号，然后是另一个数字:2。

假设您正在编写一个类似于12+3的字符串:它将读取字符1、2、+和3。我们有各自独立的角色，但我们必须把它们组合在一起；分词器的主要任务之一。例如，我们将1和2作为单独的字母，但是我们需要将它们放在一起，并作为单个整数进行解析。+也需要被识别为加号，而不是它的文字字符值——字符代码43。

如果您可以看到代码，并以这种方式使其更有意义，那么下面的 Rust tokenizer 可以将数字分组为 32 位整数，并将加号作为Token值Plus。

[## 铁锈操场

play.rust-lang.org](https://play.rust-lang.org/?gist=070c3b6b985098a306c62881d7f2f82c&version=stable&mode=debug&edition=2015)

您可以点击 Rust Playground 左上角的“运行”按钮，在您的浏览器中编译并执行代码。

在编程语言的编译器中，词法分析器可能需要几种不同类型的标记。例如:符号、数字、标识符、字符串、运算符等。知道需要从源代码中提取哪种单独的标记完全取决于语言本身。

Example of C source code that has been lexically analyzed, and its tokens printed.

2.从语法上分析

解析器确实是语法的核心。**解析器获取由词法分析器生成的标记，尝试查看它们是否符合特定的模式，然后将这些模式与像调用函数、调用变量或数学运算这样的表达式相关联。**解析器是真正定义语言语法的东西。

说int a = 3和a: int = 3的区别在于解析器。解析器决定语法应该是什么样子。它确保括号和花括号是平衡的，每个语句都以分号结束，并且每个函数都有一个名称。当标记不符合预期模式时，解析器知道什么时候事情没有按照正确的顺序进行。

你可以编写几种不同类型的 解析器 。其中最常见的是自上而下，递归下降解析器。递归下降解析是最容易使用和理解的解析之一。我创建的所有解析器例子都是基于递归下降的。

解析器解析的语法可以用语法来概括。像 EBNF 这样的语法可以描述像12+3这样的简单数学运算的解析器:

EBNF grammar for simple addition and subtraction expressions.

记住语法文件是 而不是 解析器，而是解析器工作的概要。你可以围绕这样的语法构建一个解析器。它将由人类使用，比直接查看解析器的代码更容易阅读和理解。

该语法的解析器将是expr解析器，因为它是基本上所有内容都与之相关的顶级项目。唯一有效的输入必须是任何数字，加或减，任何数字。expr期待一个additive_expr，这是大加减法出现的地方。additive_expr先预计一个term(一个数字)，然后加减，再一个term。

Example AST generated for parsing 12+3.

*解析器在解析时生成的树称为 抽象语法树 **，简称 AST。*AST 包含所有的操作。解析器不计算操作，它只是按照正确的顺序收集它们。

我添加了之前的 lexer 代码，这样它就能匹配我们的语法，并能生成如图所示的 ASTs。我用注释// BEGIN PARSER //和// END PARSER //标记了新解析器代码的开头和结尾。

*[## 铁锈操场

play.rust-lang.org](https://play.rust-lang.org/?gist=205deadb23dbc814912185cec8148fcf&version=stable&mode=debug&edition=2015)*

我们实际上可以走得更远。比方说，我们希望支持没有运算的数字输入，或者添加乘法和除法，甚至添加优先级。通过快速修改语法文件，并在解析器代码中反映出来，这一切都是可能的。

The new grammar.

*[## 铁锈操场

play.rust-lang.org](https://play.rust-lang.org/?gist=1587a5dd6109f70cafe68818a8c1a883&version=nightly&mode=debug&edition=2018)*

Scanner (a.k.a. lexer) and parser example for C. Starting from the sequence of characters "if(net>0.0)total+=net*(1.0+tax/100.0);", the scanner composes a sequence of tokens, and categorizes each of them, e.g. as identifier, reserved word, number literal, or operator. The latter sequence is transformed by the parser into a syntax tree, which is then treated by the remaining compiler phases. The scanner and parser handles the regular and properly context-free parts of the grammar for C, respectively. Credit: Jochen Burghardt. Original.

3.生成代码

代码生成器接受一个 AST 并发出代码或汇编中的等价代码。代码生成器必须以递归下降的顺序遍历 AST 中的每一项——很像解析器的工作方式——然后发出等价的代码。

* [## 编译器资源管理器- Rust (rustc 1.29.0)

pub fn main(){ let a = 10 * 3；}

godbolt.org](https://godbolt.org/z/K8416_)

如果打开上面的链接，可以看到左边的示例代码生成的程序集。汇编代码的第 3 行和第 4 行显示了编译器在 AST 中遇到常量时是如何为它们生成代码的。

god bolt 编译器资源管理器是一款优秀的工具，允许你用高级编程语言编写代码，并查看其生成的汇编代码。您可以用它来看看应该生成什么样的代码，但是不要忘记在您的语言的编译器中添加优化标志，看看它有多聪明。( *-O* 为铁锈)

如果您对编译器如何将局部变量保存到 ASM 的内存中感兴趣，本文(“代码生成”一节)将详细解释堆栈。大多数情况下，当变量不在本地时，高级编译器会在堆上为变量分配内存，并将它们存储在堆上，而不是堆栈上。你可以在这个 StackOverflow 回答中阅读更多关于存储变量的内容。

因为组装是一个完全不同的复杂的主题，所以我不会详细讨论它。我只想强调代码生成器的重要性和作用。此外，代码生成器不仅仅可以生成汇编。 Haxe 编译器有一个 后端 可以生成超过六种不同的编程语言；包括 C++、Java 和 Python。

后端指编译器的代码生成器或评估器；因此，前端是词法分析器和语法分析器。还有一个中间端，它主要与优化和 IRs 有关，这将在本节后面解释。后端大多与前端无关，只关心自己收到的 AST。这意味着一个人可以为几个不同的前端或语言重用同一个后端。臭名昭著的 GNU 编译器合集 就是如此。

我没有比我的 C 编译器后端更好的代码生成器的例子了；你可以在这里找到。

生成汇编后，它将被写入一个新的汇编文件(.s或.asm)。然后，该文件将通过汇编器传递，汇编器是用于汇编的编译器，它将生成等价的二进制文件。然后，二进制代码将被写入一个名为目标文件的新文件中(.o)。

目标文件是机器代码，但不可执行。为了使它们成为可执行的，目标文件需要被链接在一起。链接器获取这个通用机器码，并使其成为可执行文件，一个共享库，或者一个静态库。更多关于联系人 这里 。

链接程序是根据操作系统而变化的实用程序。一个单独的第三方链接器应该能够编译后端生成的目标代码。在制作编译器时，应该不需要创建自己的链接器。

*一个编译器可能有一个中间表示，或者 IR。**IR 是为了优化或翻译成另一种语言而无损地表示原始指令。*IR 不是原始源代码；IR 是为了在代码中找到潜在的优化而进行的无损简化。循环展开和矢量化使用 IR 完成。更多与 IR 相关的优化示例可以在本 PDF 中找到。

结论

当你理解了编译器，你就能更有效地使用你的编程语言。也许有一天你会对制作自己的编程语言感兴趣？我希望这对你有帮助。

资源和延伸阅读

• http://craftinginterpreters.com/—指导你用 C 和 Java 创建一个解释器。
• https://norasandler.com/2017/11/29/Write-a-Compiler.html——可能是对我最有益的“编写编译器”教程。
• 我的 C 编译器和科学计算器解析器可以在这里和这里找到。
• 另一种类型的解析器的例子，称为优先攀爬解析器，可以在这里找到。致谢:韦斯利·诺里斯。*

理解合成模式产生网络(上)

原文：https://towardsdatascience.com/understanding-compositional-pattern-producing-networks-810f6bef1b88?source=collection_archive---------4-----------------------

全面解释 CPPNs 背后的理论

3

在过去的两年里，我一直在研究复合模式产生网络(CPPN)，这是一种在1中提出的扩充拓扑神经网络。然而，在我的整个研究中，我总是对 CPPNs 背后的一些概念和理论感到困惑，我努力理解它们是如何工作的。虽然网上有一些 CPPN 的开源版本，但在我的研究中，我想为定制目的构建自己的实现，这比我最初预期的要复杂得多。因此，我想对 CPPN 背后的理论以及如何实现它们进行全面的解释，以便像我一样与 CPPN 斗争的每个人都可以获得这样的资源。这篇文章将分成两个独立的部分。您现在正在阅读的第一部分将关注 CPPN 背后的理论以及它们是如何在科学研究中使用的，而第二部分将关注用 Python 实际实现 CPPN。

这是什么鬼东西？CPPNs 理论

在1中提出，CPPNs 是对以前提出的神经网络的扩展，称为 NEAT 2。这些类型的神经网络非常相似，所以我将概述 NEAT 背后的一些理论，然后快速说明 CPPNs 的不同之处(别担心，它们几乎是相同的)。首先，NEAT 是一个用遗传算法进化的扩充拓扑神经网络。对这意味着什么的解释可以分成两个相关的概念:进化/遗传算法和扩充拓扑网络。

遗传算法

进化/遗传算法(GA)用于训练和优化神经网络的参数，类似于反向传播或爬山。然而，GA 不是使用导数来总是朝着改善损失的方向调整网络的权重，而是通过计算机版本的自然选择来找到最优的权重集，从达尔文主义和适者生存中汲取灵感。通过创建一个巨大的可能权重矩阵“群体”(通常约 25–100，但这可以变化)，g a 可以评估群体中每个“个体”的损失，每个个体由一个唯一的权重矩阵表示。使用该信息，最佳权重矩阵然后被变异，彼此交叉，并被选择以前进到下一个“代”。通过在选择过程的许多代或迭代中重复该过程，GA 可以创建最小化损失的权重矩阵的最终群体，从而产生许多可能的性能最优的权重矩阵。

变异是通过随机扰动单个网络的权重来执行的，而交叉是通过将一个网络的权重与另一个网络的权重部分交换来执行的。这些概念对我来说总是有点困惑，所以这里是两组权重交叉和变异的直观表示:

Crossing Over Weight Matrices (found at https://github.com/lagodiuk/evo-neural-network-agents)

从上图中可以看出，在交叉过程中，很大一部分权重在权重矩阵之间交换，从而产生两个不同于原始“父”权重集的“子”权重集。在变异过程中，一些权重在随机方向上被扰动，以使“子”权重集与原始权重集略有不同。

这种变异、交叉和选择生存的最佳权重矩阵的过程重复许多代，直到你剩下最佳权重矩阵的最终群体。使用这种方法，只有最好的解决方案才能进入下一代，以便进一步变异、交叉和探索。因此，随着时间的推移，使用达尔文的适者生存原则来优化种群。如果你很好奇，想了解更多关于 GA 的知识，我鼓励你查看这个链接，它比我在这里给出的解释要深入得多。

扩充拓扑神经网络

通常，遗传算法在一组结构相同的网络上工作。扩充拓扑神经网络也利用 GA，但是它们允许 GA 在进化期间操纵神经网络的结构(不仅仅是权重)，从而允许找到神经网络的最佳结构/拓扑。在进化之初，所有神经网络都是用完全连接到输出的输入来初始化的，没有隐藏节点——这是一个非常简单的最小结构。然而，随着拓扑的增加，随着神经网络的权重“进化”，网络的结构同时被优化——这在典型的 GA 优化中不会发生。为了探索可能的网络拓扑，当允许扩充拓扑时，GA 通过添加隐藏节点、添加更多的连接、甚至删除群体中某些拓扑内的现有连接来增加网络的复杂性。因此，虽然网络在进化之初结构简单，但它们的拓扑结构会进化到产生更高的性能，从而允许训练创建更复杂的网络结构。扩充拓扑的概念是 NEAT/CPPN 背后的核心思想，在我看来，这也是模型如此强大的原因。下图直观地展示了在进化过程中拓扑突变是如何应用于网络的:

Mutating Neural Network Structure 2

在上图中，一个现有的连接被拆分为两个新的连接，并且在这两个连接之间添加了一个节点。除了这种类型的拓扑突变(称为节点突变)，NEAT 还有向网络中添加连接的拓扑突变(连接添加突变)和从网络中删除连接的拓扑突变(连接删除突变)。这种拓扑扩充导致最终的网络群体在结构上非常多样化，但都完成类似的任务-群体中的每个网络可能具有不同的拓扑，以不同的方式解决问题。

CPPN 和 NEAT 的区别？

既然您对 NEAT 有了很高的理解，您可能会好奇为什么我要写一个与标题中提到的(CPPN)完全不同的网络类型，但是这两者之间的区别非常简单。CPPN 允许每个节点包含从可能的激活功能列表中选择的唯一激活功能，而不是在每个节点中使用相同的激活功能。该激活列表可能包括 sin、cos、tanh、sigmoid、relu 或您可能想要包括的任何其他激活函数。允许神经网络包含许多不同的激活函数，反过来，允许它对展示所有这些不同激活的属性的函数进行建模，并创建模式化的、对称的和独特的输出。由于 CPPN 能够创建如此复杂和有趣的几何图形，因此它的目的是生成各种 2D 和 3D 形状。CPPN 的输入是像素的 x 和 y(甚至可能是 z)位置，它输出该输入位置的像素值(在[0，1]或[白色、黑色]之间)。对 2D 或 3D 空间内的每个可能的像素位置重复这种激活，以产生完整的输出形状。下图显示了 CPPN 的典型激活:

2D CPPN Activation 1

在该图像中，可以观察到像素的 x 和 y 位置被输入到 CPPN 中，并且在该 x 和 y 位置的像素的强度值被输出。CPPN 中的每个节点都包含一个独特的激活函数，该函数根据输入值以不同方式影响输出值。通过对 2D 或 3D 空间内的每个像素位置执行 CPPN 的激活，可以创建有趣的结构和图案，如下所示:

CPPN Black and White Output 1

CPPN Color Output (found on picbreeder.com)

从上面的输出中可以看出，CPPN 产生规则和对称形状的能力非常适合于发展类似艺术品、活生物体和许多其他有趣几何形状的结构。在我看来，这样的应用和能力非常有趣，这也是为什么我觉得研究 CPPNs 如此有趣。

演进中的 CPPNs 的细节

在进化开始时，cppn 的群体以不包含隐藏节点的简单结构初始化，但是，由于 cppn 的扩充拓扑特征，随着进化的继续和拓扑突变的应用，群体变得越来越复杂。在每一代中，额外的节点和连接被添加到网络结构中，从而产生越来越复杂且更适于解决预期问题的网络。然而，认识到群体中的所有网络不会同时突变是非常重要的，因此，每个网络可能具有与群体中其他 CPPNs 不同的拓扑结构。网络拓扑之间缺乏一致性使得 cppn 的发展变得有些独特和困难，因此我认为有必要解释一些 cppn 通常如何发展以及如何处理这种缺乏结构一致性的细节。

历史标记

每次一个新的连接被添加到 CPPN 的拓扑结构中，它都会被赋予一个“历史标记”或“创新号”，这只是一个特定连接所特有的整数。添加到群体中每个 CPPN 的每个连接都被赋予一个唯一的历史标记。随着连接在整个进化过程中的增加，全局计数器被维护并递增，使得分配的每个历史标记都是唯一的。这样的历史标记允许你理解人口中每个联系的历史和血统。此外，当结构在进化过程中相互交叉时，人们可以使用历史标记来观察哪些连接具有相似的进化血统。通过对添加的连接执行这种简单的簿记，进化 CPPNs 的几个方面被大大简化。在下图中，你可以观察到一个连接列表及其对应的创新编号(创新编号和历史标记是一回事！).

List of Connections 2

请注意，上图中的每个连接都被分配了一个创新号，并且每个连接的创新号都是唯一的。这允许您确定群体中的哪些网络共享共同的连接，从而从相同的结构中派生出来。

cppn 的交叉

如前所述，用遗传算法进化神经网络的一部分涉及交叉——在网络之间交换权重值以创建新的网络。对于遗传算法神经网络的典型进化，交叉是非常简单的。下图显示了相同拓扑网络之间常见的交叉类型:

Different Types of Crossover

对于扩充拓扑 CPPNs 的发展，由于两个网络之间的权重数目可能不相同，交叉变得稍微复杂。然而，创新数字的使用大大简化了这一过程。不是试图找到一种特殊的方法来决定哪些权重相互交叉，而是只交叉具有相同创新数的权重。因此，可以简单地通过在两个网络之间找到具有相等新息数的连接并交换它们的权重来执行交叉，从而产生 CPPNs 之间的伪一致交叉。

通过物种形成保护多样性

随着拓扑突变(新的连接和节点)被添加到群体中的 CPPNs 的拓扑中，这种突变通常会导致适应度的初始下降。这种适应度的降低是由这样的事实引起的，即在初始化时放入网络的新权重是随机的，并且尽管拓扑变化可以提供更优的结构，但是在网络实现其全部潜力之前必须训练这样的权重。网络中的这种新的随机权重通常会导致网络的适应性最初下降，然后在权重被训练后提高。如果我们不保护这样的网络不被选择，允许它们有时间训练并实现它们的最大适应度，它们将被 GA 立即从种群中淘汰，这将阻止 CPPNs 探索更复杂的结构。幸运的是，这样的新结构可以通过一个叫做“物种形成”的重要概念得以保存。

就个人而言，物种形成是我在研究 cppn 时最难理解的概念，但没有它，cppn 就无法有效进化。物种形成背后的基本概念是，当被选择用于下一代时，cppn 应该只与具有相似拓扑结构的 cppn 竞争。这样，如果通过变异创建了具有新的更复杂拓扑的网络，它将不必与已经达到其最大适应度的不太复杂的拓扑竞争，从而给更复杂的网络时间来训练和提高其适应度。拓扑的相似性通过比较网络之间的新息数来评估——如果网络有许多具有相同新息数的连接，则它们更相似，反之亦然。使用这样的信息，当执行选择时，基于新息数距离度量，CPPNs 被分成几个“种类”，或者具有相似拓扑的不同组。一旦这些物种形成，对每个物种分别进行选择，允许 CPPNs 只与它们物种的其他成员竞争。这种方法允许具有新的不同结构的 CPPNs 存在足够长的时间用于训练和优化，以发现这种拓扑是否是最佳的。

CPPN 演进总结

如果你理解了发展 cppn 的所有这些特殊细节，你就对 cppn 背后的理论有了很好的理解，并且可能理解使用 cppn 发表的大多数论文和项目。我相信这张图很好地总结了这些细节:

Evolution Details 2

如上图所示，要进化的 CPPNs 的群体从最低限度开始——完全连接，在任何结构中都没有隐藏节点。随着进化的进行，拓扑和重量突变被应用于 CPPNs，这允许它们生长，在结构上变得更复杂，并优化它们的参数。当新的连接被添加到 CPPNs 中时，它们每个都被赋予一个唯一的历史标记(或创新号),允许识别相似的连接。然后，这些历史标记可以用于创建不同网络拓扑之间的距离/相似性度量，这允许基于它们的网络结构将 CPPNs 分成不同的物种。通过对每个物种分别进行选择，允许新的 CPPN 拓扑在选择和进化中存活足够长的时间，以探索它们的能力，从而允许找到并优化最佳网络结构。

涉及 CPPN 的项目/研究示例

既然你已经理解了 cppn 是如何工作的，以及它们能做的很酷的事情，那么看看一些用 cppn 完成的研究项目可能会有所帮助，其中一些项目在计算进化领域相当有影响力。

pic breader 网站

在研究 CPPNs 时面临的最初问题之一是，在许多情况下，很难确定某个网络的适合度。每个 CPPN 输出一个独特的形状或图像，给这样的输出分配一个适合度是非常主观的——用户必须根据他们的偏好来确定适合度。Picbreeder.com 是一个作为研究项目开发的网站，完全基于用户的偏好，大规模地众包 CPPNs 的演变。使用 CPPNs 编码许多不同的图像，该网站允许用户选择他们喜欢的图像，并通过不断选择图像的变异版本来进一步进化它们。进化甚至可以在以后由不同的用户在相同的图像上继续。这样一个平台允许 CPPNs 完全基于主观用户输入，进化了令人难以置信的多代，这导致了各种有趣输出的集体创造。以下是网站上一些图片的例子:

Top Images on picbreeder.com

正如上面所看到的，一些非常有趣和令人印象深刻的图像是通过这样的合作进化创造出来的。此外，这项研究中的进化结果有效地证明了 CPPNs 的许多有价值的特性，使它们变得有用和有趣。例如，考虑下面一组也是使用 picbreeder 开发的图像:

Living Organism Images from picbreeder.com

从上面的图像中可以清楚地看到，CPPNs 可以产生类似于活生物体的对称和规则的几何形状，这是它们产生的主要动机之一。因此，picbreeder.com 进化的结果巩固了 CPPNs 在实现这一目的方面的有效性。

软体机器人进化

已经发表了许多论文来探索具有图像的 CPPNs 的 2D 应用，但是我发现许多最有趣的应用涉及 3D 形状的产生。CPPNs 最突出的 3D 应用之一是研究由 CPPNs 间接编码以实现最大行驶距离的软机器人的进化。现在，你可能在想“等等，到底什么是软体机器人”，所以这里有一张本文中软体机器人的快速图片:

Soft Robot Example 3

在这项研究中，软机器人是通过向 3D 空间添加材料来创建的，这些材料可以以不同的方式扩展和收缩(因此是“软”机器人)，这使得机器人像生命体一样移动。这些软机器人是通过用不同类型的体素(3D 像素)填充 3D 空间(或者没有体素/空白空间)来创建结构而创建的。每种类型的体素(由不同的颜色表示)不同地收缩或松弛，从而当配对在一起时，体素的运动可以产生结构的整体运动。这种结构是通过查询输出空间中每个可能的体素位置处的 CPPN 以产生每个体素的类型和存在的输出来创建的。在这项研究中，该模型还使用距空间中心的距离(d)作为输入，但我发现对位置输入值进行归一化可以减少网络中的参数数量，并且表现类似。如果您仍然有一点困惑，这里是 CPPNs 如何在这个项目中用于创建软机器人输出的可视化:

Creating a Soft Robot with CPPN 3

每个结构都通过模拟来评估，模拟确定了每个软机器人在给定时间内移动的距离。这项研究成功地进化出了能够移动最大距离的 CPPNs，有趣的是，这些进化的结构中有许多在移动中类似于活的有机体(如果你感兴趣，请查看这个视频)。).此外，当这个问题试图只使用软机器人的直接编码(直接存储结构中每个体素的值)并用 GA 进化时，它根本不起作用，从而证明了 CPPNs 在创建逼真的功能性生物方面的有用性和有效性。以下是这项研究中进化出的一些最好的软体机器人的图片:

Set of Results from Soft Robot Evolution 3

其他论文/研究

有很多论文探讨了 CPPNs 的有效性和功能，但是写这些文章可能会花费很长时间(我相信您已经厌倦了阅读)。因此，以下是我在研究过程中发现的一些关于 CPPNs 的有用且有趣的额外论文:

1. 上传任何物体并进化它:将复杂的几何图案注入 CPPNs 以进一步进化
2. 在一个开放的、互动的进化系统中，管道化和可进化性的出现
3. 受发育生物学启发，用生殖编码进化三维物体

结论

非常感谢你的阅读！我希望您现在对 CPPNs 以及如何使用它们有了更好的理解。如果你很好奇，想了解更多关于 CPPN 的知识，我真的鼓励你访问 NEAT 的网页，它是由 NEAT 的创建者创建的，允许研究人员分享关于 NEAT 的想法和方法(记住，NEAT 几乎与 CPPN 相同，所以大多数想法/技巧都适用于两者！).此外，请随时在 LinkedIn上联系我或者在 GitHub 上关注我。

引文

1 K. O .斯坦利一种新的发展抽象。遗传编程和进化机器，2007。

2 K. O .斯坦利和 r .米库拉宁。通过扩充拓扑进化神经网络。进化计算，2002。

3 Cheney，n .，MacCurdy，r .，Clune，j .和 Lipson，h.《解开束缚的进化:用多种材料和强大的生成编码进化出柔软的机器人》。遗传和进化计算会议论文集。纽约计算机学会，2013 年。

理解混淆矩阵

原文：https://towardsdatascience.com/understanding-confusion-matrix-a9ad42dcfd62?source=collection_archive---------0-----------------------

Understanding Confusion Matrix [Image 1] (Image courtesy: My Photoshopped Collection)

当我们得到数据后，经过数据清理、预处理和争论，我们做的第一步是把它输入到一个优秀的模型中，当然，得到概率输出。但是坚持住！我们到底如何衡量我们模型的有效性。效果越好，性能越好，这正是我们想要的。这也是混淆矩阵引人注目的地方。混淆矩阵是机器学习分类的性能度量。

本博客旨在回答以下问题:

1. 混淆矩阵是什么，为什么需要它？
2. 如何计算二类分类问题的混淆矩阵？

今天我们就来一劳永逸的了解一下混淆矩阵。

什么是混淆矩阵，为什么你需要它？

嗯，这是对机器学习分类问题的性能测量，其中输出可以是两个或更多个类。这是一个包含预测值和实际值的 4 种不同组合的表格。

Confusion Matrix [Image 2] (Image courtesy: My Photoshopped Collection)

它对测量召回率、精确度、特异性、准确性以及最重要的 AUC-ROC 曲线非常有用。

我们从怀孕类比的角度来理解 TP，FP，FN，TN。

Confusion Matrix [Image 3] (Image courtesy: My Photoshopped Collection)

真阳性:

解读:你预测的是正的，这是真的。

你预言一个女人怀孕了，她真的怀孕了。

真否定:

解读:你预测的是负数，这是真的。

你预言一个男人不会怀孕，他实际上也没有。

假阳性:(1 型错误)

解读:你预测的是正的，是假的。

你预言一个男人怀孕了，但他实际上没有。

假阴性:(2 型错误)

解读:你预测的是负数，这是假的。

你预测一个女人不会怀孕，但她确实怀孕了。

请记住，我们将预测值描述为正和负，将实际值描述为真和假。

Actual vs Predicted values [Image 4] (Image courtesy: My Photoshopped Collection)

如何计算二类分类问题的混淆矩阵？

让我们通过数学来理解混淆矩阵。

Confusion Matrix [Image 5 and 6] (Image 5 courtesy: My Photoshopped Collection) (Image 6 courtesy: I can not find the source. If you know please comment. I will provide appropriate citations. 😄)

召回

Recall [Image 7] (Image courtesy: My Photoshopped Collection)

上面的等式可以解释为，从所有的正类中，我们正确预测了多少。

召回率要尽可能高。

精度

Precision [Image 8] (Image courtesy: My Photoshopped Collection)

上面的等式可以解释为，从我们预测为正的所有类中，有多少实际上是正的。

精度要尽可能高。

和

精度

从所有的类(正类和负类)中，我们正确预测了多少。在这种情况下，它将是 4/7。

精确度应该尽可能高。

F-measure

F1 Score [Image 9] (Image courtesy: My Photoshopped Collection)

低精度和高召回率的两个模型很难比较，反之亦然。所以为了使它们具有可比性，我们使用 F-Score。F-score 有助于同时衡量查全率和查准率。它用调和平均值代替算术平均值，更多地惩罚极值。

我希望我已经让你对混淆矩阵有了一些基本的了解。如果你喜欢这篇文章，给这篇文章一些掌声会对你有所帮助👏。我随时欢迎你的问题和建议。你可以在脸书、推特、Linkedin 上分享这个，这样有需要的人可能会偶然发现这个。

您可以通过以下方式联系到我:

领英:https://www.linkedin.com/in/narkhedesarang/

推特:【https://twitter.com/narkhede_sarang

github:【https://github.com/TheSarang

感谢阅读！

理解卷积神经网络

原文：https://towardsdatascience.com/understanding-convolutional-neural-networks-221930904a8e?source=collection_archive---------3-----------------------

在这篇博文中，我们将探索(或至少尝试)卷积神经网络背后的直觉，卷积神经网络是机器视觉和图像识别中最重要的深度学习技术之一。我们还将通过一个例子来使用卷积神经网络识别不同的形状。

一些背景

随着人工智能的突破继续吸引着普通公众，诸如*、【人工智能】、、【机器学习】、、【深度学习】、等术语已经被互换使用。为了更好地了解人工智能在未来几年的发展方向，理解每个术语之间的差异绝对是值得的。*

The concentric circles of Artificial Intelligence

我们可以将这三个术语视为同心圆，人工智能包含机器学习，机器学习包含深度学习。我们可以更深入地研究人工智能的历史以及这一进步是如何产生的——但是关于这个话题已经讨论了很多。

简而言之，人工智能是计算机系统的发展，它执行通常保留给人类认知的任务。例如，尽管是一个硬编码系统，但计算器是一种人工智能。用于开发这种系统的技术是这些同心圆的关键。

机器学习围绕着创建可以从大型数据集学习有用模式的系统，并因此提供有用的见解。机器学习本身分为三个主要类别——第一个是监督学习，它需要创建理解一组数据点*(上下文)和标签(结果)之间关系的系统，从而提供未标记数据点的结果。此类系统的示例包括对贷款申请是否会导致违约进行分类的系统、预测未来股票价格的系统等。或者，无监督学习正在构建能够简单地基于相似特征或特性从数据集中识别有意义模式的系统。例如，根据相似的购物行为对客户进行聚类。最后，强化学习是机器学习的一个分支，它试图将智能代理置于一个定义明确的环境中，有一组可能的动作和一个目标函数(奖励)要最大化。我们可以想到自动驾驶汽车(代理)行驶在高速公路上(环境)其唯一的目标是不发生事故(奖励)*例如。

最后，深度学习是一种在机器学习中使用的技术，它利用大量数据和多层神经网络*(可以在这里找到神经网络的优秀遍历*)，以便理解数据集内的模式。最近人工智能在计算机视觉和语音识别等方面的突破几乎都回到了深度学习研究，更重要的是计算能力的商品化(一篇关于计算能力在人工智能研究中的使用的有趣博客文章可以在这里找到*)*。**

直观地说，把机器学习想象成对孩子大脑建模的尝试。儿童从他人的动作中学习(监督学习)试图辨别世界上不同物体之间的相似性，例如将形状相似的乐高积木组合在一起(无监督学习)并在没有直接输入的情况下导航困难的环境，例如攀登架(强化学习)。深度学习是机器学习中的一种技术，是人工智能最近突破的根源。

什么是卷积神经网络？

在深度学习中，出现了大量的架构和技术，可以实现许多用例，其中主要是卷积神经网络。卷积神经网络的灵感来自于对哺乳动物视觉皮层的研究，以及它们如何使用大脑中神经元的分层结构来感知世界。把这个视觉皮层模型想象成专门设计来识别不同形状的神经元群。每组神经元在看到一个物体时都会放电，并相互交流，以形成对感知物体的整体理解。

Different groups of neurons in the brain learn to recognize different groups of characteristics given an input stimulus

该系统可以被解释为神经元的分级集群，其检测输入刺激的低级特征，并在该分级结构中相互通信，以开发对象的高级检测。
将层次结构想象成如下:

• 第一个聚类作为识别低级特征的结构(即面部轮廓)
• 第二类是识别颜色和形状的结构(肤色或颌线)
• 第三个是识别细节的结构(耳朵、鼻子和眼睛……)
• 最终聚类从整体上识别整个对象(脸部和附在脸部的人)