多键多值非确定性python字典

Question

在python中已经有了一个multi key dict和一个多值dict。我需要一个python字典，它既有：

示例：

# probabilistically fetch any one of baloon, toy or car
d['red','blue','green']== "baloon" or "car" or "toy"  

d['red']==d['green']的概率很高，d['red']的概率！=d['red']较低，但有可能

单个输出值应根据键的规则进行概率确定（模糊） 例：在上面的情况下，规则可能是如果钥匙同时有“红色”和“蓝色”，则返回“baloon”80%的时间，如果只有蓝色，则返回“玩具”15%的时间，否则“汽车”5%的时间。在

setitem方法的设计应使以下内容成为可能：

^{pr2}$

上面使用谓词函数和相应的概率将多个值赋给字典。而不是上面的作业列表，甚至是字典作为作业更可取：

d["red", "blue"] ={ 
    "baloon": haseither('red','green',0.8),
    "toy": hasonly("blue",0.15),
    "car": default(0.05)
}

在上述情况下，如果出现“红色”或“绿色”，将返回80%的时间 ，如有蓝色，则退还玩具15%的时间，无条件退还汽车5%的时间。在

在python中有没有已经满足上述要求的现有数据结构？如果没有，那么如何在python中修改multikeydict代码以满足上述要求？在

如果使用dictionary，那么可以有一个配置文件或使用适当的嵌套修饰符来配置上述概率谓词逻辑，而不必硬编码if\else语句。在

注意：以上是基于规则的自动响应程序应用程序的一个有用的自动机，因此请告诉我python中是否有类似的基于规则的框架，即使它不使用字典结构？在

Answer 1

模拟多键词典

^{}不允许^{}同时具有多个密钥。。。在

（例如d["red", "green"]）

多键可以用^{}或^{}键来模拟。如果顺序无关紧要，^{}似乎是最好的（实际上是散列的^{}，因此["red", "blue"]与["blue", "red"]相同。在

模拟多元词典

多值是使用某些数据类型固有的，它可以是any storage element，可以方便地编制索引。标准^{}应该提供这一点。在

非决定论

使用由规则和假设定义的概率分布¹，使用python文档中的this recipe执行非确定性选择。在

MultiKeyMultiValNonDeterministicDict类

多好的名字啊。\o/^-不错！

此类接受多个键，这些键定义了一个由多个值组成的概率规则集。在项目创建（^{}）期间，所有键组合的值概率都会预先计算¹。在项目访问（^{}）期间，选择预先计算的概率分布，并基于随机加权选择对结果进行评估。在

定义

import random
import operator
import bisect
import itertools

# or use itertools.accumulate in python 3
def accumulate(iterable, func=operator.add):
    'Return running totals'
    # accumulate([1,2,3,4,5]) --> 1 3 6 10 15
    # accumulate([1,2,3,4,5], operator.mul) --> 1 2 6 24 120
    it = iter(iterable)
    try:
        total = next(it)
    except StopIteration:
        return
    yield total
    for element in it:
        total = func(total, element)
        yield total

class MultiKeyMultiValNonDeterministicDict(dict):

    def key_combinations(self, keys):
        """get all combinations of keys"""
        return [frozenset(subset) for L in range(0, len(keys)+1) for subset in itertools.combinations(keys, L)]

    def multi_val_rule_prob(self, rules, rule):
        """
        assign probabilities for each value, 
        spreading undefined result probabilities
        uniformly over the leftover results not defined by rule.
        """
        all_results = set([result for result_probs in rules.values() for result in result_probs])
        prob = rules[rule]
        leftover_prob = 1.0 - sum([x for x in prob.values()])
        leftover_results = len(all_results) - len(prob)
        for result in all_results:
            if result not in prob:
                # spread undefined prob uniformly over leftover results
                prob[result] = leftover_prob/leftover_results
        return prob

    def multi_key_rule_prob(self, key, val):
        """
        assign probability distributions for every combination of keys,
        using the default for combinations not defined in rule set
        """ 
        combo_probs = {}
        for combo in self.key_combinations(key):
            if combo in val:
                result_probs = self.multi_val_rule_prob(val, combo).items()
            else:
                result_probs = self.multi_val_rule_prob(val, frozenset([])).items()
            combo_probs[combo] = result_probs
        return combo_probs

    def weighted_random_choice(self, weighted_choices):
        """make choice from weighted distribution"""
        choices, weights = zip(*weighted_choices)
        cumdist = list(accumulate(weights))
        return choices[bisect.bisect(cumdist, random.random() * cumdist[-1])]

    def __setitem__(self, key, val):
        """
        set item in dictionary, 
        assigns values to keys with precomputed probability distributions
        """

        precompute_val_probs = self.multi_key_rule_prob(key, val)        
        # use to show ALL precomputed probabilities for key's rule set
        # print precompute_val_probs        

        dict.__setitem__(self, frozenset(key), precompute_val_probs)

    def __getitem__(self, key):
        """
        get item from dictionary, 
        randomly select value based on rule probability
        """
        key = frozenset([key]) if isinstance(key, str) else frozenset(key)             
        val = None
        weighted_val = None        
        if key in self.keys():
            val = dict.__getitem__(self, key)
            weighted_val = val[key]
        else:
            for k in self.keys():
                if key.issubset(k):
                    val = dict.__getitem__(self, k)
                    weighted_val = val[key]

        # used to show probabality for key
        # print weighted_val

        if weighted_val:
            prob_results = self.weighted_random_choice(weighted_val)
        else:
            prob_results = None
        return prob_results

使用

^{pr2}$

测试

检查概率

N = 10000
red_green_test = {'car':0.0, 'toy':0.0, 'ballon':0.0}
red_blue_test = {'car':0.0, 'toy':0.0, 'ballon':0.0}
blue_test = {'car':0.0, 'toy':0.0, 'ballon':0.0}
red_blue_green_test = {'car':0.0, 'toy':0.0, 'ballon':0.0}
default_test = {'car':0.0, 'toy':0.0, 'ballon':0.0}

for _ in xrange(N):
    red_green_test[d["red","green"]] += 1.0
    red_blue_test[d["red","blue"]] += 1.0
    blue_test[d["blue"]] += 1.0
    default_test[d["green"]] += 1.0
    red_blue_green_test[d["red","blue","green"]] += 1.0

print 'red,green test      =', ' '.join('{0}: {1:05.2f}%'.format(key, 100.0*val/N) for key, val in red_green_test.items())
print 'red,blue test       =', ' '.join('{0}: {1:05.2f}%'.format(key, 100.0*val/N) for key, val in red_blue_test.items())
print 'blue test           =', ' '.join('{0}: {1:05.2f}%'.format(key, 100.0*val/N) for key, val in blue_test.items())
print 'default test        =', ' '.join('{0}: {1:05.2f}%'.format(key, 100.0*val/N) for key, val in default_test.items())
print 'red,blue,green test =', ' '.join('{0}: {1:05.2f}%'.format(key, 100.0*val/N) for key, val in red_blue_green_test.items())

---

red,green test      = car: 09.89% toy: 10.06% ballon: 80.05%
red,blue test       = car: 05.30% toy: 47.71% ballon: 46.99%
blue test           = car: 41.69% toy: 15.02% ballon: 43.29%
default test        = car: 05.03% toy: 47.16% ballon: 47.81%
red,blue,green test = car: 04.85% toy: 49.20% ballon: 45.95%

概率符合规则！

---

脚注

1. 分布假设

   由于规则集没有完全定义，所以对概率分布进行了假设，大部分假设都是在^{中完成的。基本上，任何未定义的概率都将均匀地分布在剩余值上。这是针对所有键组合进行的，并为随机加权选择创建一个通用键接口。在

   给出示例规则集

   d["red","blue","green"] = {
       # {rule_set} : {result: probability}
       frozenset(["red", "green"]): {"ballon": 0.8},
       frozenset(["blue"]): {"toy": 0.15},
       frozenset([]): {"car": 0.05}
   }
   

   这将创建以下发行版

   'red'           = [('car', 0.050), ('toy', 0.475), ('ballon', 0.475)]
   'green'         = [('car', 0.050), ('toy', 0.475), ('ballon', 0.475)]
   'blue'          = [('car', 0.425), ('toy', 0.150), ('ballon', 0.425)]
   'blue,red'      = [('car', 0.050), ('toy', 0.475), ('ballon', 0.475)]
   'green,red'     = [('car', 0.098), ('toy', 0.098), ('ballon', 0.800)]
   'blue,green'    = [('car', 0.050), ('toy', 0.475), ('ballon', 0.475)]
   'blue,green,red'= [('car', 0.050), ('toy', 0.475), ('ballon', 0.475)]
    default        = [('car', 0.050), ('toy', 0.475), ('ballon', 0.475)]
   

   如果这是不正确的，请告知。

Answer 2

如果可以更改数据结构，那么使用返回所需数据的函数会更简单。这将是完全灵活的，可以容纳任何类型的数据，如果您以后需要更改它们。在

import random

def myfunc(*args):
    if 'red' in args:
        return 'blue'
    elif 'green' in args or 'violet' in args:
        return 'violet'
    else:
        r = random.random()
        if 0 < r < 0.2:
            return 'blue'
        else:
            return 'green'

print(myfunc('green', 'blue'))
print(myfunc('yellow'))

输出（第二行明显改变）：

^{pr2}$

Answer 3

the single output value should be probabilistically determined (fuzzy) based on a rule from keys eg:in above case rule could be if keys have both "red" and "blue" then return "baloon" 80% of time if only blue then return "toy" 15% of time else "car" 5% of time.

请记住，您的案例分析并不完整，而且很模糊，但您可以“在精神上”做以下事情（充实所需的结果）：

import random

def randomly_return(*colors):
    colors = set(*colors)
    if 'red' in colors and 'blue' in colors:
        if random.random() < 0.8:  # 80 % of the time
            return "baloon"

    if 'blue' in colors and len(colors) == 1:  # only blue in colors
        if random.random() < 0.15:
            return "toy"
        else:
            if random.random() < 0.05:
                return "car"

# other cases to consider

---

我会把它作为一个函数，因为它是一个函数！但是如果您坚持让它像dict一样，那么python让您通过重写__getitem__（在我看来它不是python）来实现这一点。在

^{pr2}$

---

并希望通过OP获得澄清：

randreturn((haseither(red,blue),baloon:0.8),((hasonly(blue),toy:0.15)),(default(‌​),car:0.05)))

要生成如下函数：

funcs = {"haseither": lambda needles, haystack: any(n in haystack for n in needles),
         "hasonly": lambda needles, haystack: len(needles) == 1 and needles[1] in haystack}

def make_random_return(crits, default):
    def random_return(*colors):
        colors = set(*colors)
        for c in crits:
            if funcs[c["func"]](c["args"], colors) and random.random() > c["with_prob"]:
                return c["return_value"]
        return default
    return random_return

在这种情况下，临界值和默认值是：

crit = [{"func": "haseither", "args": ("red", "blue"), "return_value": "baloon", "with_prob": 0.8}, ...]
default = "car"  # ??
my_random_return = make_random_return(crits, default)

正如我所说，你的概率是模棱两可的/不加总的，所以你很可能需要调整一下。。。

可以通过在实例化时传递crit和default来扩展类定义：

class RandomlyReturn(object):
    def __init__(self, crit, default):
        self.randomly_return = make_random_return(crit, default)
    def __getitem__(self, *colors):
        return self.randomly_return(*colors)

>>> r = RandomlyReturn(crit, default)
>>> r["red", "blue"]  # 80% of the time it'll return "baloon"
"baloon"