Question

我正在尝试验证用户提供的一系列字词。我正在努力想出一个评分系统来确定这一系列单词确实是有效单词的可能性。

假设以下输入：

xxx yyy zzz

我要做的第一件事是根据我拥有的单词数据库单独检查每个单词。所以，假设xxx在数据库中，所以我们100％确定它是一个有效的单词。然后让我们说数据库中不存在yyy，但存在其拼写的可能变体（比如yyyy）。我们不会给yyy 100％的分数，但可能会低一些（比方说90％）。然后zzz在数据库中根本不存在。因此，zzz得分为0％。

所以我们有这样的事情：

xxx = 100%
yyy = 90%
zzz = 0%

进一步假设用户要么：

提供所有有效字词的列表（最有可能）
提供所有无效字词的列表（可能）
提供有效和无效字词组合的列表（不太可能）

总的来说，确定xxx yyy zzz是一系列有效词的置信度得分的好评分系统是什么？我不是在寻找任何过于复杂的东西，但获得平均分数似乎并不合适。如果单词列表中的某些单词有效，我认为它增加了数据库中找不到的单词也是实际单词的可能性（这只是数据库的一个限制，它不包含该单词）。 / p>

注意：输入通常至少为2个单词（大多数为2个单词），但可以是3,4,5（在极少数情况下甚至更多）。

Answer 1

编辑我添加了一个新的部分，将歧视性词组分为英语和非英语组。这低于估计任何给定单词是否为英语的部分。

我认为你觉得你在这里解释的评分系统并不能完全解决这个问题。

找到字典中的单词很棒 - 这些单词可以立即给出100％并通过，但是不匹配的单词呢？你怎么能确定他们的概率？这可以通过包含完全相同字母的句子之间的简单比较来解释：

Abergrandly收到的wuzkinds
Erbdnerye wcgluszaaindid vker

两个句子都没有任何英文单词，但第一句看起来像英文 - 可能是某人（Abergrandly）收到（有拼写错误）的几个项目（wuzkinds）。第二句话显然只是我的婴儿敲击键盘。

因此，在上面的示例中，即使没有英语单词，英语使用者说出的概率也很高。第二句有0％的英语概率。

我知道一些启发式方法可以帮助发现差异：

简单frequency analysis个字母

A typical distribution of letters in English. From Wikipedia

在任何语言中，某些字母比其他字母更常见。简单地计算每个字母的发生率并将其与平均语言进行比较可以告诉我们很多。

有几种方法可以从中计算概率。一个可能是：

制备
1. 计算或获取合适的英语语料库中的字母频率。 NLTK是一个很好的开始方式。相关的Natural Language Processing with Python book非常有用。
测试
1. 计算要测试的短语中每个字母的出现次数
2. 计算每个字母点的坐标为Linear regression的位置：
  1. X轴：其预测频率从1.1以上
  2. Y轴：实际计数
3. 对数据执行Regression Analysis
  1. 英语应报告接近1.0的正r。将R ^ 2计算为英语的概率。
  2. 0或以下的r与英语无关，或字母具有负相关。不太可能是英语。

优点：

计算非常简单

缺点：

对于小样本不会那么好用，例如＆＃34; zebra，xylophone＆＃34;
＆＃34; Rrressseee＆＃34;似乎很可能是一个字
不区分我上面给出的两个例句。

Bigram frequencies和Trigram频率

这是字母频率的扩展，但会查看字母对或三元组的频率。例如，u跟随q的频率为99％（为什么不是100％？dafuq）。同样，NLTK语料库非常有用。

Digraph frequency based on a sample to 40,000 words

以上：http://www.math.cornell.edu/~mec/2003-2004/cryptography/subs/digraphs.jpg

这种方法在整个行业中得到广泛应用，从语音识别到软键盘上的预测文本等各个方面。

Trigraphs特别有用。考虑一下＆＃39; ll＆＃39;是一个非常常见的有向图。字符串＆＃39; lllllllll＆＃39;因此只包含常见的有向图，而有向图方法使它看起来像一个单词。 Trigraphs解决了这个问题因为＆＃39; lll＆＃39;永远不会发生。

使用三字符计算单词概率不能用一个简单的线性回归模型来完成（绝大多数三元组都不会出现在单词中，所以大多数点都在x上轴）。相反，您可以使用马尔可夫链（使用双字母或三字母的概率矩阵）来计算单词的概率。马尔可夫链的介绍是here。

首先建立一个概率矩阵：

X轴：每个二元组（＆＃34; th＆＃34;，＆＃34;他＆＃34;，＆＃34;在＆＃34;，＆＃34;呃＆＃34;，＆＃34;＆＃34;等）
Y轴：字母表中的字母。
矩阵成员包括跟随bigraph的字母表字母的概率。

要从单词的开头开始计算概率，X轴有向图需要包括空格-a，空格-b到空格-z-例如有向图＆＃34;空格＆＃34; t表示从t开始的单词。

计算单词的概率包括迭代有向图并获得给出有向图的第三个字母的概率。例如，单词＆＃34;他们＆＃34;被分解为以下概率：

h关注＆＃34;空间＆＃34; t - ＆gt;概率 x ％
e以下 - ＆gt;概率 y ％
y跟随他 - ＆gt;概率 z ％

整体概率= x * y * z ％

此计算通过突出显示＆＃34; wcgl＆＃34;来解决简单频率分析的问题。具有0％的概率。

请注意，任何给定单词的概率都非常小，并且在每个额外字符的统计上小于10x到20x。但是，从大型语料库中检查已知英语单词3,4,5,6等字符的概率，您可以确定一个截止点，低于该截止值的单词极不可能。每个极不可能的三字母都会使英语的可能性降低1到2个数量级。

然后，您可以对一个单词的概率进行标准化，例如，对于8个字母的英语单词（我已经编写了下面的数字）：

马尔可夫链的概率：
- 最佳英文单词的概率= 10 ^ -7（10％* 10％* .. * 10％）
- 截止（最不可能的英文单词概率）= 10 ^ -14（1％* 1％* .. * 1％）
- 测试词的概率（说＆＃34; coattail＆＃34;）= 10 ^ -12
＆＃39;规格化＆＃39;结果
- 记录日志：最好= -7;测试= -12;截止= -14
- 积极：最佳= 7;测试= 2;截止= 0
- 在1.0和0.0之间归一化：最佳= 1.0;测试= 0.28;截止= 0.0
- （您可以轻松地将上限和下限调整为，例如，介于90％和10％之间）

现在我们已经研究了如何更好地概括任何给定的单词是英语，让我们看看这组单词。

该小组的定义是，它至少有2个单词，但可以是3,4,5或（在少数情况下）更多。你没有提到单词之间有任何压倒一切的结构或关联，所以我不假设：

任何一组都是一个短语，例如＆＃34;坦克指挥官＆＃34;，＆＃34;红字日＆＃34;
该组是一个句子或条款，例如＆＃34;我口渴＆＃34;，＆＃34;玛丽需要一封电子邮件＆＃34;

然而如果这个假设是错误的，那么对于较大的单词组来说问题变得更容易处理，因为这些单词将符合英语的语法规则 - 我们可以使用，例如， NLTK解析该条款以获得更多洞察力。

查看一组单词是英语的可能性

好的，为了了解问题，让我们看一下不同的用例。在以下内容中：

我将忽略所有单词或所有非单词的情况，因为这些情况是微不足道的
我会考虑类似英语的单词，你可以假设它们不在字典中，比如古怪的姓氏（例如Kardashian），不寻常的产品名称（例如stackexchange）等等。
我将使用概率的简单平均值，假设随机乱码为0％，而类似英语的单词为90％。

两个字

（50％）Red ajkhsdjas
（50％）Hkdfs Friday
（95％）Kardashians计划
（95％）使用Stackexchange

从这些例子中，我认为你会同意1.和2.可能是不可接受的，而3.和4.是。对于两个单词组，简单平均计算似乎是一个有用的鉴别器。

三个字

有一个可疑的话：

（67％）Red dawn dskfa
（67％）Hskdkc共产主义宣言
（67％）经济危机
（97％）Kardashian十五分钟
（97％）stackexchange用户体验

显然4.和5.是可以接受的。

但是1.，2。还是3.？ 1.，2.或3之间是否存在材料差异？可能不会，排除使用Baysian统计数据。但这些应该归类为英语吗？我认为这是你的电话。

有两个可疑的词：

（33％）Red ksadjak adsfhd
（33％）jkdsfk dsajjds宣言
（93％）Stackexchange通过电子邮件向Kardashians发送电子邮件
（93％）Stackexchange Kardashian帐户

我会冒险1.和2.不可接受，但3.和4肯定是。（好吧，除了Kardashians＆＃39;在这里有一个帐户 - 这不是好兆头）。同样，简单平均值可以用作简单的鉴别器 - 您可以选择它是高于还是低于67％。

四个字

排列的数量开始变得狂野，所以我只举几个例子：

一个可疑的词：
1. （75％）今天编写jhjasd语言
2. （93％）绝望的卡戴珊电视连续剧
两个疑似词：
1. （50％）今天编程kasdhjk jhsaer
2. （95％）实现Kasdashian过滤器的Stackexchange
三个可疑词：
1. （25％）编程sdajf jkkdsf kuuerc
2. （93％）Stackexchange比特卡戴珊推文

在我看来，很清楚哪些词组有意义与简单平均值对齐，但2.1除外 - 这又是你的召唤。

有趣的是，四个单词组的截止点可能与三个单词组不同，因此我建议您的实现具有不同的每个组的配置设置。具有不同截止值的结果是从2> 3然后3-> 4的量子跃迁与平滑，连续概率的概念不相符。

为这些群体实施不同的截止值直接解决了你的直觉问题。现在，我只有一个＆＃34; gut＆＃34;感觉我的xxx yyy zzz示例确实应该高于66.66％，但我不确定如何将其表达为公式。＆＃34; 。

五个字

你明白了 - 我不打算再在这里列举。然而，当你得到五个单词时，它开始得到足够的结构，几个新的启发式可以进来：

使用贝叶斯概率/统计量（第三个词是前两个词的概率是多少？）
使用NLTK解析小组并查看它是否具有语法意义

问题案例

英语有很多非常短的单词，这可能会导致问题。例如：

Gibberish：r xu r
这是英文吗？我是

您可能必须编写代码来专门测试1个和2个字母的单词。

TL; DR摘要

可以测试非词典单词的英语＆＃39; （或法语或西班牙语等）他们使用字母和三字母频率。拾取类似英语的单词并将其归为高分对于区分英语组是至关重要的
最多四个单词，一个简单的平均值具有很强的辨别能力，但你可能想为2个单词，3个单词和4个单词设置不同的截止值。
您可以开始使用贝叶斯统计数据
较长的单词组如果它们应该是句子或句子片段可以使用自然语言工具测试，例如NLTK。
这是一个启发式过程，最终会有混淆的价值观（例如＆＃34;我是＆＃34;）。因此，与简单的平均值相比，编写完美的统计分析例程可能不是特别有用，如果它可能被大量例外情况混淆。

Answer 2

也许您可以使用Bayes' formula。

您已经对每个单词的真实概率进行了数字猜测。

下一步是对整个列表好，坏或混合的概率进行有根据的猜测（即将“最有可能”，“可能”和“不太可能”转化为数字。）

Answer 3

我将提供贝叶斯分层模型解决方案。它有一些必须手动设置的参数，但是对于这些参数非常稳健，如下面的模拟所示。它不仅可以处理单词列表的评分系统，还可以处理输入单词的用户的可能分类。处理可能有点技术性，但最后我们有一个例程来计算得分作为3个数字的函数：列表中的单词数，数据库中具有完全匹配的单词数，以及部分匹配的数量（如yyyy）。该例程在R中实现，但如果你从未使用它，只需下载解释器，将代码复制并粘贴到它的控制台中，你就会看到这里显示的结果。

BTW英语不是我的第一语言，所以请耐心等待......： - ）

<强> 1。型号规格：

有3类用户，名为I，II，III。我们假设每个单词列表由单个用户生成，并且用户是从用户范围中随机抽取的。我们说这个宇宙是70％的I级，25％的II级和5％的III级。当然，这些数字可以改变。到目前为止我们已经

了

Prob [User = I] = 70％

Prob [User = II] = 25％

Prob [User = III] = 5％

鉴于用户，我们假设条件独立，即用户不会查看先前的单词来决定他是否输入有效或无效的单词。

用户我倾向于只提供有效的单词，用户II只提供无效的单词，而用户III则是混合的。所以我们设置

Prob [Word = OK |用户= I] = 99％

Prob [Word = OK |用户= II] = 0.001％

Prob [Word = OK |用户= III] = 50％

根据用户的类别，单词无效的概率是互补的。请注意，我们给出了II级用户输入有效单词的非常小但非零的概率，因为即使是打字机前面的猴子，最终也会输入一个有效的单词。

模型规范的最后一步是关注数据库。我们假设，对于每个单词，查询可能有3个结果：总匹配，部分匹配（如yyyy中）或不匹配。在概率方面，我们假设

问题[匹配|有效] = 98％（并非所有有效单词都会被找到）

Prob [partial |有效期] = 0.2％（罕见事件）

问题[匹配| INvalid] = 0（数据库可能不完整，但没有无效的单词）

Prob [partial |无效] = 0.1％（罕见事件）

找不到单词“don”的概率必须设置，因为它们是互补的。就是这样，我们的模型已经确定。

<强> 2。符号和目标

我们有一个离散随机变量U，取{1,2,3}中的值和两个离散随机向量W和F，每个大小为n（=单词数），其中W_i为1，如果单词是有效，如果单词无效，则为2;如果在数据库中找到单词，则F_i为1;如果部分匹配则为2，如果未找到，则为3。

只有矢量F是可观察的，其他的是潜在的。使用贝叶斯定理和我们在模型规范中建立的分布，我们可以计算

（a）Prob [User = I | F]，

我。例如，给定观察到的匹配，用户在第一类中的后验概率;和

（b）Prob [W =全部有效| F]，

我。例如，给定观察到的匹配，所有单词都有效的后验概率。

根据您的目标，您可以使用其中一种作为评分解决方案。例如，如果您有兴趣区分真实用户和计算机程序，可以使用（a）。如果你只关心单词列表是否有效，你应该使用（b）。

我将在下一节中尝试简要解释该理论，但这是贝叶斯分层模型背景下的常用设置。参考文献是Gelman（2004），＆＃34;贝叶斯数据分析＆＃34;。

如果需要，可以使用代码跳转到第4部分。

第3。数学

我会像往常一样使用略微滥用的符号，写作

x（y）表示Prob [X = x | Y = y]，p（x，y）表示Prob [X = x，Y = y]。

目标（a）是计算p（u | f），u = 1。使用贝叶斯定理：

p（u | f）= p（u，f）/ p（f）= p（f | u）p（u）/ p（f）。

给出了p（u）。 p（f | u）来自：

p（f | u）= \ prod_ {i = 1} ^ {n} \ sum_ {w_i = 1} ^ {2}（p（f_i | w_i）p（w_i | u））

p（f | u）= \ prod_ {i = 1} ^ {n} p（f_i | u）

= p（f_i = 1 | u）^（m）p（f_i = 2 | u）^（p）p（f_i = 3）^（n-m-p）

其中m =匹配数，p =部分匹配数。

p（f）计算如下：

\ sum_ {u = 1} ^ {3} p（f | u）p（u）

所有这些都可以直接计算。

目标（b）由

提供

p（w | f）= p（f | w）* p（w）/ p（f）

，其中

p（f | w）= \ prod_ {i = 1} ^ {n} p（f_i | w_i）

和p（f_i | w_i）在模型规范中给出。

p（f）计算如上，所以我们只需要

p（w）= \ sum_ {u = 1} ^ {3} p（w | u）p（u）

，其中

p（w | u）= \ prod_ {i = 1} ^ {n} p（w_i | u）

所以一切都准备好了。

<强> 4。守则

代码是作为R脚本编写的，根据上面讨论的内容，常量设置在开头，输出由函数给出

（a）p.u_f（u，n，m，p）

和

（b）p.wOK_f（n，m，p）

计算选项（a）和（b）的概率，给定输入：

u =所需的用户类别（设置为u = 1）
n =单词数量
m =匹配数量
p =部分匹配的数量

代码本身：

### Constants:

# User:

# Prob[U=1], Prob[U=2], Prob[U=3]

Prob_user = c(0.70, 0.25, 0.05)

# Words:

# Prob[Wi=OK|U=1,2,3]

Prob_OK = c(0.99, 0.001, 0.5)

Prob_NotOK = 1 - Prob_OK

# Database:

# Prob[Fi=match|Wi=OK], Prob[Fi=match|Wi=NotOK]:

Prob_match = c(0.98, 0)

# Prob[Fi=partial|Wi=OK], Prob[Fi=partial|Wi=NotOK]:

Prob_partial = c(0.002, 0.001)

# Prob[Fi=NOmatch|Wi=OK], Prob[Fi=NOmatch|Wi=NotOK]:

Prob_NOmatch = 1 - Prob_match - Prob_partial


###### First Goal: Probability of being a user type I, given the numbers of matchings (m) and partial matchings (p).


# Prob[Fi=fi|U=u]
#
p.fi_u <- function(fi, u)
{
    unname(rbind(Prob_match, Prob_partial, Prob_NOmatch) %*% rbind(Prob_OK, Prob_NotOK))[fi,u]
}

# Prob[F=f|U=u]
#
p.f_u <- function(n, m, p, u)
{
    exp( log(p.fi_u(1, u))*m + log(p.fi_u(2, u))*p + log(p.fi_u(3, u))*(n-m-p) )
}

# Prob[F=f]
#
p.f <- function(n, m, p)
{
    p.f_u(n, m, p, 1)*Prob_user[1] + p.f_u(n, m, p, 2)*Prob_user[2] + p.f_u(n, m, p, 3)*Prob_user[3]
}

# Prob[U=u|F=f]
#
p.u_f <- function(u, n, m, p)
{
    p.f_u(n, m, p, u) * Prob_user[u] / p.f(n, m, p)
}

# Probability user type I for n=1,...,5:

for(n in 1:5) for(m in 0:n) for(p in 0:(n-m))
{
    cat("n =", n, "| m =", m, "| p =", p, "| Prob type I =", p.u_f(1, n, m, p), "\n")
}

##################################################################################################

# Second Goal: Probability all words OK given matchings/partial matchings.

p.f_wOK <- function(n, m, p)
{
    exp( log(Prob_match[1])*m + log(Prob_partial[1])*p + log(Prob_NOmatch[1])*(n-m-p) )
}

p.wOK <- function(n)
{
    sum(exp( log(Prob_OK)*n + log(Prob_user) ))
}

p.wOK_f <- function(n, m, p)
{
    p.f_wOK(n, m, p)*p.wOK(n)/p.f(n, m, p)
}

# Probability all words ok for n=1,...,5:

for(n in 1:5) for(m in 0:n) for(p in 0:(n-m))
{
    cat("n =", n, "| m =", m, "| p =", p, "| Prob all OK =", p.wOK_f(n, m, p), "\n")
}

<强> 5。结果

这是n = 1，...，5的结果，以及m和p的所有可能性。例如，如果你有3个单词，一个匹配，一个部分匹配，一个未找到，你可以66.5％确定它是一个I类用户。在相同的情况下，您可以将所有单词有效的分数归因为42.8％。

请注意，选项（a）不会对所有匹配的情况给出100％的分数，但选项（b）会给出。这是预期的，因为我们假设数据库没有无效的单词，因此如果它们都被找到，那么它们都是有效的。 OTOH，II级或III级用户输入所有有效单词的可能性很小，但随着n的增加，这种机会会迅速减少。

（a）中

n = 1 | m = 0 | p = 0 | Prob type I = 0.06612505 
n = 1 | m = 0 | p = 1 | Prob type I = 0.8107086 
n = 1 | m = 1 | p = 0 | Prob type I = 0.9648451 
n = 2 | m = 0 | p = 0 | Prob type I = 0.002062543 
n = 2 | m = 0 | p = 1 | Prob type I = 0.1186027 
n = 2 | m = 0 | p = 2 | Prob type I = 0.884213 
n = 2 | m = 1 | p = 0 | Prob type I = 0.597882 
n = 2 | m = 1 | p = 1 | Prob type I = 0.9733557 
n = 2 | m = 2 | p = 0 | Prob type I = 0.982106 
n = 3 | m = 0 | p = 0 | Prob type I = 5.901733e-05 
n = 3 | m = 0 | p = 1 | Prob type I = 0.003994149 
n = 3 | m = 0 | p = 2 | Prob type I = 0.200601 
n = 3 | m = 0 | p = 3 | Prob type I = 0.9293284 
n = 3 | m = 1 | p = 0 | Prob type I = 0.07393334 
n = 3 | m = 1 | p = 1 | Prob type I = 0.665019 
n = 3 | m = 1 | p = 2 | Prob type I = 0.9798274 
n = 3 | m = 2 | p = 0 | Prob type I = 0.7500993 
n = 3 | m = 2 | p = 1 | Prob type I = 0.9864524 
n = 3 | m = 3 | p = 0 | Prob type I = 0.990882 
n = 4 | m = 0 | p = 0 | Prob type I = 1.66568e-06 
n = 4 | m = 0 | p = 1 | Prob type I = 0.0001158324 
n = 4 | m = 0 | p = 2 | Prob type I = 0.007636577 
n = 4 | m = 0 | p = 3 | Prob type I = 0.3134207 
n = 4 | m = 0 | p = 4 | Prob type I = 0.9560934 
n = 4 | m = 1 | p = 0 | Prob type I = 0.004198015 
n = 4 | m = 1 | p = 1 | Prob type I = 0.09685249 
n = 4 | m = 1 | p = 2 | Prob type I = 0.7256616 
n = 4 | m = 1 | p = 3 | Prob type I = 0.9847408 
n = 4 | m = 2 | p = 0 | Prob type I = 0.1410053 
n = 4 | m = 2 | p = 1 | Prob type I = 0.7992839 
n = 4 | m = 2 | p = 2 | Prob type I = 0.9897541 
n = 4 | m = 3 | p = 0 | Prob type I = 0.855978 
n = 4 | m = 3 | p = 1 | Prob type I = 0.9931117 
n = 4 | m = 4 | p = 0 | Prob type I = 0.9953741 
n = 5 | m = 0 | p = 0 | Prob type I = 4.671933e-08 
n = 5 | m = 0 | p = 1 | Prob type I = 3.289577e-06 
n = 5 | m = 0 | p = 2 | Prob type I = 0.0002259559 
n = 5 | m = 0 | p = 3 | Prob type I = 0.01433312 
n = 5 | m = 0 | p = 4 | Prob type I = 0.4459982 
n = 5 | m = 0 | p = 5 | Prob type I = 0.9719289 
n = 5 | m = 1 | p = 0 | Prob type I = 0.0002158996 
n = 5 | m = 1 | p = 1 | Prob type I = 0.005694145 
n = 5 | m = 1 | p = 2 | Prob type I = 0.1254661 
n = 5 | m = 1 | p = 3 | Prob type I = 0.7787294 
n = 5 | m = 1 | p = 4 | Prob type I = 0.988466 
n = 5 | m = 2 | p = 0 | Prob type I = 0.00889696 
n = 5 | m = 2 | p = 1 | Prob type I = 0.1788336 
n = 5 | m = 2 | p = 2 | Prob type I = 0.8408416 
n = 5 | m = 2 | p = 3 | Prob type I = 0.9922575 
n = 5 | m = 3 | p = 0 | Prob type I = 0.2453087 
n = 5 | m = 3 | p = 1 | Prob type I = 0.8874493 
n = 5 | m = 3 | p = 2 | Prob type I = 0.994799 
n = 5 | m = 4 | p = 0 | Prob type I = 0.9216786 
n = 5 | m = 4 | p = 1 | Prob type I = 0.9965092 
n = 5 | m = 5 | p = 0 | Prob type I = 0.9976583

（b）中

n = 1 | m = 0 | p = 0 | Prob all OK = 0.04391523 
n = 1 | m = 0 | p = 1 | Prob all OK = 0.836025 
n = 1 | m = 1 | p = 0 | Prob all OK = 1 
n = 2 | m = 0 | p = 0 | Prob all OK = 0.0008622994 
n = 2 | m = 0 | p = 1 | Prob all OK = 0.07699368 
n = 2 | m = 0 | p = 2 | Prob all OK = 0.8912977 
n = 2 | m = 1 | p = 0 | Prob all OK = 0.3900892 
n = 2 | m = 1 | p = 1 | Prob all OK = 0.9861099 
n = 2 | m = 2 | p = 0 | Prob all OK = 1 
n = 3 | m = 0 | p = 0 | Prob all OK = 1.567032e-05 
n = 3 | m = 0 | p = 1 | Prob all OK = 0.001646751 
n = 3 | m = 0 | p = 2 | Prob all OK = 0.1284228 
n = 3 | m = 0 | p = 3 | Prob all OK = 0.923812 
n = 3 | m = 1 | p = 0 | Prob all OK = 0.03063598 
n = 3 | m = 1 | p = 1 | Prob all OK = 0.4278888 
n = 3 | m = 1 | p = 2 | Prob all OK = 0.9789305 
n = 3 | m = 2 | p = 0 | Prob all OK = 0.485069 
n = 3 | m = 2 | p = 1 | Prob all OK = 0.990527 
n = 3 | m = 3 | p = 0 | Prob all OK = 1 
n = 4 | m = 0 | p = 0 | Prob all OK = 2.821188e-07 
n = 4 | m = 0 | p = 1 | Prob all OK = 3.046322e-05 
n = 4 | m = 0 | p = 2 | Prob all OK = 0.003118531 
n = 4 | m = 0 | p = 3 | Prob all OK = 0.1987396 
n = 4 | m = 0 | p = 4 | Prob all OK = 0.9413746 
n = 4 | m = 1 | p = 0 | Prob all OK = 0.001109629 
n = 4 | m = 1 | p = 1 | Prob all OK = 0.03975118 
n = 4 | m = 1 | p = 2 | Prob all OK = 0.4624648 
n = 4 | m = 1 | p = 3 | Prob all OK = 0.9744778 
n = 4 | m = 2 | p = 0 | Prob all OK = 0.05816511 
n = 4 | m = 2 | p = 1 | Prob all OK = 0.5119571 
n = 4 | m = 2 | p = 2 | Prob all OK = 0.9843855 
n = 4 | m = 3 | p = 0 | Prob all OK = 0.5510398 
n = 4 | m = 3 | p = 1 | Prob all OK = 0.9927134 
n = 4 | m = 4 | p = 0 | Prob all OK = 1 
n = 5 | m = 0 | p = 0 | Prob all OK = 5.05881e-09 
n = 5 | m = 0 | p = 1 | Prob all OK = 5.530918e-07 
n = 5 | m = 0 | p = 2 | Prob all OK = 5.899106e-05 
n = 5 | m = 0 | p = 3 | Prob all OK = 0.005810434 
n = 5 | m = 0 | p = 4 | Prob all OK = 0.2807414 
n = 5 | m = 0 | p = 5 | Prob all OK = 0.9499773 
n = 5 | m = 1 | p = 0 | Prob all OK = 3.648353e-05 
n = 5 | m = 1 | p = 1 | Prob all OK = 0.001494098 
n = 5 | m = 1 | p = 2 | Prob all OK = 0.051119 
n = 5 | m = 1 | p = 3 | Prob all OK = 0.4926606 
n = 5 | m = 1 | p = 4 | Prob all OK = 0.9710204 
n = 5 | m = 2 | p = 0 | Prob all OK = 0.002346281 
n = 5 | m = 2 | p = 1 | Prob all OK = 0.07323064 
n = 5 | m = 2 | p = 2 | Prob all OK = 0.5346423 
n = 5 | m = 2 | p = 3 | Prob all OK = 0.9796679 
n = 5 | m = 3 | p = 0 | Prob all OK = 0.1009589 
n = 5 | m = 3 | p = 1 | Prob all OK = 0.5671273 
n = 5 | m = 3 | p = 2 | Prob all OK = 0.9871377 
n = 5 | m = 4 | p = 0 | Prob all OK = 0.5919764 
n = 5 | m = 4 | p = 1 | Prob all OK = 0.9938288 
n = 5 | m = 5 | p = 0 | Prob all OK = 1

Answer 4

如果“平均”没有解决方案，因为数据库缺少单词，我会说：扩展数据库：）

另一个想法可能是，“权衡”结果，以获得调整后的平均值，例如：

100% = 1.00x weight
90%  = 0.95x weight
80%  = 0.90x weight
...
0%   = 0.50x weight

所以对于你的例子，你会：

(100*1 + 90*0.95 + 0*0.5) / (100*1 + 100*0.95 + 100*0.5) = 0.75714285714
 => 75.7%
regular average would be 63.3%

Answer 5

由于单词的顺序在您的描述中并不重要，因此自变量是有效单词的一部分。如果分数是完美的1，即发现所有单词都与DB完美匹配，那么您完全可以确保获得全部有效结果。如果它为零，即所有单词都是DB中的完美未命中，那么你完全肯定会得到无效的结果。如果你有.5，那么这必然是不太可能的混淆结果，因为其他两个都不可能。

你说混合的结果是不可能的，而两个极端更多。你是在追求全部有效结果的可能性之后。

让有效单词的分数（匹配/单词数的“确定性”之和）为f，因此所有有效结果的期望可能性为L（f）。到目前为止的讨论中，我们知道L（1）= 1并且L（f）= 0，0 <= f <= 1/2。

为了保证您的信息混合结果不如全有效（和无效）结果，L的形状必须单调且快速地从1/2向1上升，并在f = 1时达到1 。

由于这是启发式的，我们可能会选择具有此角色的任何合理函数。如果我们很聪明，它将有一个参数来控制步骤的陡度，也许还有另一个参数来控制它的位置。这让我们可以调整“不太可能”对中间案例的意义。

对于1/2＆lt; = f＆lt; = 1：

，这是一个这样的函数

L(f) = 5 + f * (-24 + (36 - 16 * f) * f) + (-4 + f * (16 + f * (-20 + 8 * f))) * s

并且0为0＆lt; = f＆lt; 0 1/2。虽然看起来像毛茸茸的，但它是最简单的多项式，它与（1 / 2,0）和（1,1）相交，f = 1时斜率为0，f = 0时斜率为s。

您可以设置0＆lt; = s＆lt; = 3来更改步形状。这是s = 3的镜头，可能是你想要的： Screen shot of function plot

如果你设置s＆gt; 3，在安定下来之前它会超过1，而不是我们想要的。

当然，还有其他许多可能性。如果这个不起作用，请评论，我们会寻找另一个。

Answer 6

当然，平均值是垃圾。如果单个词的概率是准确的，那么所有单词都是正确的概率只是产品，而不是平均值。如果您对个体概率的不确定性有一个估计，那么您可以计算出所有个体概率边缘化的产品。

评分系统建议 - 加权机制？

6 个答案: