如何建立模型以区分关于Apple（Inc.）的推文和关于Apple（fruit）的推文？

请参阅以下有关“苹果”的50条推文。我亲手写了有关Apple Inc.的正面匹配。它们在下面标记为1。

以下是几行：

1|“@chrisgilmer: Apple targets big business with new iOS 7 features http://bit.ly/15F9JeF ”. Finally.. A corp iTunes account!
0|“@Zach_Paull: When did green skittles change from lime to green apple? #notafan” @Skittles
1|@dtfcdvEric: @MaroneyFan11 apple inc is searching for people to help and tryout all their upcoming tablet within our own net page No.
0|@STFUTimothy have you tried apple pie shine?
1|#SuryaRay #India Microsoft to bring Xbox and PC games to Apple, Android phones: Report: Microsoft Corp... http://dlvr.it/3YvbQx  @SuryaRay

这是总数据集：http : //pastebin.com/eJuEb4eB

我需要建立一个对“ Apple”（Inc）分类的模型。从其余的。

我不是在寻找机器学习的一般概述，而是在寻找代码中的实际模型（首选Python）。

我将按以下方式进行操作：

1. 将句子拆分为单词，对其进行规范化，然后建立字典
2. 使用每个字，存储它们在有关公司的推文中出现了多少次，以及在关于水果的推文中出现了多少次-这些推文必须由人工确认
3. 当出现新的推文时，在字典中查找推文中的每个单词，计算加权得分-与公司相关的频繁使用的单词将获得很高的公司得分，反之亦然；很少使用的单词，或者与公司和水果一起使用的单词，得分不会很高。

您正在寻找的被称为命名实体识别。这是一种统计技术（最常见的一种），它是在经过训练以学习有关命名实体的知识的基础上，使用条件随机字段来查找命名实体的。

本质上，它查看单词的内容和上下文（向前和向后看几个单词），以估计该单词是命名实体的可能性。

好的软件可以查看单词的其他特征，例如单词的长度或形状（如果单词以“ Vowel-辅音-元音”开头，则为“ Vcv”）

斯坦福大学的NER是一个很好的图书馆（GPL）

这是演示：http : //nlp.stanford.edu : 8080/ner/

一些示例文本可以尝试：

我在苹果总部吃了一个苹果，然后想到了酷玩乐队家伙的女儿苹果·马丁（Apple Martin）。

（3class和4class分类器正确无误）

我有一个可以解决此问题的半工作系统，使用scikit-learn开源，并提供了一系列描述我在做什么的博客文章。我要解决的问题是词义歧义消除（选择多个词义选项之一），这与命名实体识别不同。我的基本方法与现有解决方案具有一定的竞争力，并且（至关重要）是可定制的。

有一些现有的商业NER工具（OpenCalais，DBPedia Spotlight和AlchemyAPI）可能会给您带来足够好的商业效果-请先尝试这些！

我将其中一些用于客户项目（我在伦敦使用NLP / ML进行咨询），但我对它们的召回率（精确度和召回率）不满意。基本上，它们是精确的（当他们说“这是苹果公司”时通常是正确的），但是回想率却很低（即使对人来说，鸣叫显然是关于苹果公司的，他们很少说“这是苹果公司”）。我认为构建针对推文的开源版本在学术上会很有趣。这是当前代码： https //github.com/ianozsvald/social_media_brand_disambiguator

我会注意-我并不是要使用这种方法来解决广义的词义歧义消除问题，而只是在您已经有了名字歧义的情况下（公司，人员等）才消除品牌歧义歧义。这就是为什么我相信这种简单的方法会起作用的原因。

我是从六周前开始的，它是使用scikit-learn用Python 2.7编写的。它使用非常基本的方法。我使用1-3个n-grams使用二进制计数矢量化器（仅计算一个单词是否出现，而不计数多少次）进行矢量化 。我没有使用TF-IDF进行缩放（当文档长度可变时，TF-IDF很好；对于我来说，这些推文只有一两个句子，而我的测试结果并未显示使用TF-IDF有所改善）。

我使用了基本的分词器，这是非常基本的，但出奇的有用。它忽略@＃（因此您会丢失一些上下文），并且当然不会扩展URL。然后，我使用逻辑回归进行训练，似乎这个问题在某种程度上是线性可分离的（一个类的术语对另一个而言不存在）。目前，我正在避免进行任何清理/清理工作（我正在尝试可能会起作用的最简单的方法）。

该代码具有完整的自述文件，您应该能够相对轻松地提取自己的tweet，然后按照我的建议进行测试。

这适用于Apple，因为人们不会吃喝Apple电脑，也不会打字或玩水果，因此单词很容易分为一个类别或另一个类别。当考虑在电视节目中使用诸如#definance之类的内容时，这种情况可能不成立（人们也使用#definance来讲述《阿拉伯之春》，板球比赛，考试修订和一支音乐乐队）。这里很可能需要更聪明的方法。

我有一系列的博客文章描述了这个项目，其中包括我在BrightonPython用户组中所做的一个小时的演讲（在DataScienceLondon中变成了140人的简短演讲）。

如果使用LogisticRegression之类的方法（每个分类都有一个概率），则只能选择可信分类，这样您就可以通过与查全率进行交易来强制实现高精度（因此您可以获得正确的结果，但结果较少）。您必须将其调整到您的系统。

这是使用scikit-learn的一种可能的算法方法：

• 使用Binary CountVectorizer（我不认为短消息中的术语计数会增加很多信息，因为大多数单词只会出现一次）
• 从决策树分类器开始。它具有可解释的性能（有关示例，请参见使用决策树过度拟合）。
• 转向逻辑回归
• 研究分类器产生的错误（阅读DecisionTree的输出或查看LogisticRegression中的系数，将错误分类的推文通过Vectorizer进行处理，以查看基本的单词袋表示形式-那里的令牌少于您是从原始推文开始的-分类是否足够？）
• 在https://github.com/ianozsvald/social_media_brand_disambiguator/blob/master/learn1.py中查看我的示例代码，以获取此方法的有效版本

注意事项：

• 您需要更大的数据集。我正在使用2000条带标签的推文（花了我五个小时的时间），并且至少您希望每堂课的平衡集大于100（请参见下面的过拟合注）
• 改进令牌生成器（使用scikit-learn非常容易）以将＃@保留在令牌中，并可能添加大写的品牌检测器（如用户@ user2425429所述）
• 当事情变得困难时，考虑一个非线性分类器（如上面的@oiez的建议）。我个人发现LinearSVC的性能比逻辑回归要差（但这可能是由于我尚未减少的高维特征空间）。
• 语音标记器的特定于推文的部分（根据我的拙见，不像@Neil所建议的那样是Standford的-根据我的经验，它在糟糕的Twitter语法上表现不佳）
• 一旦有了很多令牌，您可能会希望进行降维处理（我还没有尝试过-请参阅有关LogisticRegression l1 l2惩罚的博客文章）

回覆。过度拟合。在我的2000个项目的数据集中，我有10分钟来自Twitter的“苹果”推文快照。大约2/3的推文用于Apple Inc，其他1/3用于苹果。我从每个班级中取出均衡的子集（我认为大约584行），并进行五次交叉验证以进行培训。

由于我只有10分钟的时间窗口，因此我有很多关于同一主题的推文，这可能就是为什么我的分类器相对于现有工具表现得很好的原因-它会过分适合训练功能而没有很好的概括（而现有的广告工具在此snapshop上的性能较差，但在更广泛的数据集中更可靠）。我将扩展自己的时间范围，以在以后的工作中对其进行测试。

您可以执行以下操作：

1. 做出包含其在水果和公司相关推文中出现次数的单词的字典。这可以通过向其提供一些我们知道其倾斜度的样本推文来实现。

2. 使用足够多的先前数据，我们可以找到有关apple inc的推文中某个单词出现的可能性。

3. 将各个单词的概率相乘即可得出整个推文的概率。

一个简化的例子：

p_f =水果推文的概率。

p_w_f =水果推文中出现一个单词的概率。

p_t_f =推文中所有单词出现水果推文的组合概率= p_w1_f * p_w2_f * ...

p_f_t =特定推文下水果的概率。

p_c，p_w_c，p_t_c，p_c_t是公司的相应值。

添加了值1的拉普拉斯平滑器，以消除新词零频的问题，这些新词不在我们的数据库中。

old_tweets = {'apple pie sweet potatoe cake baby https://vine.co/v/hzBaWVA3IE3': '0', ...}
known_words = {}
total_company_tweets = total_fruit_tweets =total_company_words = total_fruit_words = 0

for tweet in old_tweets:
    company = old_tweets[tweet]
    for word in tweet.lower().split(" "):
        if not word in known_words:
            known_words[word] = {"company":0, "fruit":0 }
        if company == "1":
            known_words[word]["company"] += 1
            total_company_words += 1
        else:
            known_words[word]["fruit"] += 1
            total_fruit_words += 1

    if company == "1":
        total_company_tweets += 1
    else:
        total_fruit_tweets += 1
total_tweets = len(old_tweets)

def predict_tweet(new_tweet,K=1):
    p_f = (total_fruit_tweets+K)/(total_tweets+K*2)
    p_c = (total_company_tweets+K)/(total_tweets+K*2)
    new_words = new_tweet.lower().split(" ")

    p_t_f = p_t_c = 1
    for word in new_words:
        try:
            wordFound = known_words[word]
        except KeyError:
            wordFound = {'fruit':0,'company':0}
        p_w_f = (wordFound['fruit']+K)/(total_fruit_words+K*(len(known_words)))
        p_w_c = (wordFound['company']+K)/(total_company_words+K*(len(known_words)))
    p_t_f *= p_w_f
    p_t_c *= p_w_c

    #Applying bayes rule
    p_f_t = p_f * p_t_f/(p_t_f*p_f + p_t_c*p_c)
    p_c_t = p_c * p_t_c/(p_t_f*p_f + p_t_c*p_c)
    if p_c_t > p_f_t:
        return "Company"
    return "Fruit"

如果您在使用外部库时没有问题，我建议您使用scikit-learn，因为它可能比您自己编写的任何代码更好，更快地做到这一点。我只是要做这样的事情：

建立语料库。为了清楚起见，我进行了列表推导，但是根据数据的存储方式，您可能需要做不同的事情：

def corpus_builder(apple_inc_tweets, apple_fruit_tweets):
    corpus = [tweet for tweet in apple_inc_tweets] + [tweet for tweet in apple_fruit_tweets]
    labels = [1 for x in xrange(len(apple_inc_tweets))] + [0 for x in xrange(len(apple_fruit_tweets))]
    return (corpus, labels)

重要的是，您最终得到两个看起来像这样的列表：

([['apple inc tweet i love ios and iphones'], ['apple iphones are great'], ['apple fruit tweet i love pie'], ['apple pie is great']], [1, 1, 0, 0])

[1，1，0，0]代表正负标签。

然后，您创建管道！Pipeline是一个scikit-learn类，可以轻松地将文本处理步骤链接在一起，因此在训练/预测时只需调用一个对象：

def train(corpus, labels)
    pipe = Pipeline([('vect', CountVectorizer(ngram_range=(1, 3), stop_words='english')),
                        ('tfidf', TfidfTransformer(norm='l2')),
                        ('clf', LinearSVC()),])
    pipe.fit_transform(corpus, labels)
    return pipe

管道内部有三个处理步骤。CountVectorizer对单词进行标记化，拆分，计数，然后将数据转换为稀疏矩阵。TfidfTransformer是可选的，您可能希望根据准确度等级将其删除（涉及交叉验证测试和网格搜索最佳参数，所以这里不再赘述）。LinearSVC是一种标准的文本分类算法。

最后，您预测推文的类别：

def predict(pipe, tweet):
    prediction = pipe.predict([tweet])
    return prediction

同样，该推文需要在列表中，因此我假设它是作为字符串输入函数的。

将所有这些内容放到课堂上或其他内容中，您就完成了。至少在这个非常基本的例子中。

我没有测试此代码，因此如果您仅粘贴粘贴就可能无法工作，但是如果您想使用scikit-learn，它应该让您知道从哪里开始。

编辑：试图更详细地解释步骤。

使用决策树似乎可以很好地解决此问题。至少，与使用我选择的功能的朴素贝叶斯分类器相比，它产生的准确性更高。

如果您想尝试一些可能性，可以使用以下代码，该代码需要安装nltk。该nltk图书也可以在线免费获得，因此您可能需要阅读一些有关所有这些实际工作方式的信息：http : //nltk.googlecode.com/svn/trunk/doc/book/ch06.html

#coding: utf-8
import nltk
import random
import re

def get_split_sets():
    structured_dataset = get_dataset()
    train_set = set(random.sample(structured_dataset, int(len(structured_dataset) * 0.7)))
    test_set = [x for x in structured_dataset if x not in train_set]

    train_set = [(tweet_features(x[1]), x[0]) for x in train_set]
    test_set = [(tweet_features(x[1]), x[0]) for x in test_set]
    return (train_set, test_set)

def check_accurracy(times=5):
    s = 0
    for _ in xrange(times):
        train_set, test_set = get_split_sets()
        c = nltk.classify.DecisionTreeClassifier.train(train_set)
        # Uncomment to use a naive bayes classifier instead
        #c = nltk.classify.NaiveBayesClassifier.train(train_set)
        s += nltk.classify.accuracy(c, test_set)

    return s / times


def remove_urls(tweet):
    tweet = re.sub(r'http:\/\/[^ ]+', "", tweet)
    tweet = re.sub(r'pic.twitter.com/[^ ]+', "", tweet)
    return tweet

def tweet_features(tweet):
    words = [x for x in nltk.tokenize.wordpunct_tokenize(remove_urls(tweet.lower())) if x.isalpha()]
    features = dict()
    for bigram in nltk.bigrams(words):
        features["hasBigram(%s)" % ",".join(bigram)] = True
    for trigram in nltk.trigrams(words):
        features["hasTrigram(%s)" % ",".join(trigram)] = True  
    return features

def get_dataset():
    dataset = """copy dataset in here
"""
    structured_dataset = [('fruit' if x[0] == '0' else 'company', x[2:]) for x in dataset.splitlines()]
    return structured_dataset

if __name__ == '__main__':
    print check_accurracy()

谢谢您到目前为止的评论。这是我使用PHP准备的可行解决方案。我仍然有兴趣听取其他人提供的针对该解决方案的更多算法方法。

<?php

// Confusion Matrix Init
$tp = 0;
$fp = 0;
$fn = 0;
$tn = 0;
$arrFP = array();
$arrFN = array();

// Load All Tweets to string
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'http://pastebin.com/raw.php?i=m6pP8ctM');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$strCorpus = curl_exec($ch);
curl_close($ch);

// Load Tweets as Array
$arrCorpus = explode("\n", $strCorpus);
foreach ($arrCorpus as $k => $v) {
    // init
    $blnActualClass = substr($v,0,1);
    $strTweet = trim(substr($v,2));

    // Score Tweet
    $intScore = score($strTweet);

    // Build Confusion Matrix and Log False Positives & Negatives for Review
    if ($intScore > 0) {
        if ($blnActualClass == 1) {
            // True Positive
            $tp++;
        } else {
            // False Positive
            $fp++;
            $arrFP[] = $strTweet;
        }
    } else {
        if ($blnActualClass == 1) {
            // False Negative
            $fn++;
            $arrFN[] = $strTweet;
        } else {
            // True Negative
            $tn++;
        }
    }
}

// Confusion Matrix and Logging
echo "
           Predicted
            1     0
Actual 1   $tp     $fp
Actual 0    $fn    $tn

";

if (count($arrFP) > 0) {
    echo "\n\nFalse Positives\n";
    foreach ($arrFP as $strTweet) {
        echo "$strTweet\n";
    }
}

if (count($arrFN) > 0) {
    echo "\n\nFalse Negatives\n";
    foreach ($arrFN as $strTweet) {
        echo "$strTweet\n";
    }
}

function LoadDictionaryArray() {
    $strDictionary = <<<EOD
10|iTunes
10|ios 7
10|ios7
10|iPhone
10|apple inc
10|apple corp
10|apple.com
10|MacBook
10|desk top
10|desktop
1|config
1|facebook
1|snapchat
1|intel
1|investor
1|news
1|labs
1|gadget
1|apple store
1|microsoft
1|android
1|bonds
1|Corp.tax
1|macs
-1|pie
-1|clientes
-1|green apple
-1|banana
-10|apple pie
EOD;

    $arrDictionary = explode("\n", $strDictionary);
    foreach ($arrDictionary as $k => $v) {
        $arr = explode('|', $v);
        $arrDictionary[$k] = array('value' => $arr[0], 'term' => strtolower(trim($arr[1])));
    }
    return $arrDictionary;
}

function score($str) {
    $str = strtolower($str);
    $intScore = 0;
    foreach (LoadDictionaryArray() as $arrDictionaryItem) {
        if (strpos($str,$arrDictionaryItem['term']) !== false) {
            $intScore += $arrDictionaryItem['value'];
        }
    }
    return $intScore;
}
?>

以上输出：

           Predicted
            1     0
Actual 1   31     1
Actual 0    1    17


False Positives
1|Royals apple #ASGame @mlb @ News Corp Building http://instagram.com/p/bBzzgMrrIV/


False Negatives
-1|RT @MaxFreixenet: Apple no tiene clientes. Tiene FANS// error.... PAGAS por productos y apps, ergo: ERES CLIENTE.

在您提供的所有示例中，Apple（inc）都被称为A pple或apple inc，因此一种可能的方法可能是搜索：

• 苹果中的大写字母“ A”

• 苹果之后的“ inc”

• 单词/词组，例如“ OS”，“操作系统”，“ Mac”，“ iPhone”，...

• 或它们的组合

为了简化基于条件随机字段的答案，这里的上下文很大。您将希望在那些推文中清楚地表明苹果公司与苹果公司的果实。让我在这里概述可能对您有用的功能列表。有关更多信息，请查找名词短语分块以及一些称为BIO标签的东西。参见（http://www.cis.upenn.edu/~pereira/papers/crf.pdf）

周围的单词：为前一个单词和下一个单词构建特征向量，或者如果您想要更多的特征，则可能是前两个单词和后两个单词。您不希望模型中的单词过多，否则将无法很好地匹配数据。在自然语言处理中，您将希望保持尽可能的通用。

周围单词的其他功能包括：

第一个字符是否为大写

单词的最后一个字符是否为句点

单词的词性（查找词性标签）

这个词的文字本身

我不建议这样做，而是提供更多专门针对Apple的功能示例：

WordIs（苹果）

NextWordIs（Inc。）

你明白了。可以将“命名实体识别”描述为一个序列，然后使用一些数学运算来告诉计算机如何计算该序列。

请记住，自然语言处理是基于管道的系统。通常，您将事情分解为句子，移至标记化，然后进行语音标记甚至依赖解析。

这就是给您列出可以在模型中使用以识别所需内容的功能的列表。

还有一种用于处理自然语言文本一个非常好的图书馆的Python叫nltk。您应该看看它。

您可以尝试的一种策略是查看其中带有“苹果”一词的n-gram（单词组）。在谈论水果时，在“苹果”旁边更可能使用某些词，在谈论公司时，则更可能使用其他词，您可以使用这些词来对推文进行分类。

使用LibShortText。该Python实用程序已经过调整，可用于短文本分类任务，并且效果很好。您要做的最大工作就是编写一个循环以选择最佳标志组合。我用它对电子邮件中的有监督言语行为进行分类，结果准确率高达95-97％（在5倍交叉验证中！）。

它来自LIBSVM和LIBLINEAR的制造商，它们的支持向量机（SVM）实现用于s​​klearn和cran，因此可以合理地确定它们的实现不是错误的。

制作一个AI过滤器，以区分Apple Inc（公司）和Apple（水果）。由于这些是推文，因此请使用140个字段的向量定义您的训练集，每个字段都是写在推文中X位置（0至139）的字符。如果tweet较短，请给出一个空白值。

然后建立足够大的训练集，以达到良好的准确性（取决于您的口味）。为每个推特分配结果值，Apple Inc推特获得1（真），而苹果推特（水果）获得0。这是在逻辑回归中进行监督学习的情况。

那就是机器学习，通常更容易编码并且性能更好。它必须从您提供的集合中学习，并且没有经过硬编码。

我不懂Python，所以我无法为其编写代码，但是如果您要花更多时间学习机器学习的逻辑和理论，则可能需要看看我正在关注的课程。

尝试Coursera课程机器学习由安德鲁·伍。您将在MATLAB或Octave上学习机器学习，但是一旦掌握了基础知识，只要您了解简单的数学运算（逻辑回归中的简单运算），就可以使用任何语言编写机器学习。

也就是说，从某人那里获取代码将使您无法理解机器学习代码中的运行情况。您可能需要在此主题上花费几个小时，以查看实际情况。

我建议避免回答暗示实体识别的答案。因为此任务首先是文本分类，然后是实体识别（您完全可以在没有实体识别的情况下完成此任务）。

我认为最快的结果之路将是spacy + prodigy。Spacy对英语模型进行了深思熟虑，因此您不必自己构建模型。虽然神童可以快速创建训练数据集并根据需要微调spacy模型。

如果您有足够的样本，则可以在1天之内得到一个体面的模型。