更新值时嵌套的defaultdict错误

Question

我有一本名为dQalpha的字典和另一本名为dQbeta的字典，分别计算工人的经验dQalpha[worker]和项目的难度dQbeta[example]

现在，我想添加一个名为dQgamma的新度量，它使用嵌套的defaultdict dQgamma[worker][example]来计算worker和item的相关性

但是，如果我说self.dQgamma=defaultdict(lambda: defaultdict(dict))，就会得到错误消息

TypeError: float() argument must be a string or a number

如果我说self.dQgamma=defaultdict(lambda: defaultdict(list))，我会得到这个错误消息

ValueError: setting an array element with a sequence.

有人能帮忙吗？代码如下：

self.dQalpha={}
self.dQbeta={}
self.dQgamma=defaultdict(lambda: defaultdict(dict))


der = np.zeros_like(x)
i = 0
for worker in self.workers:
    der[i] = -self.dQalpha[worker] 
    i = i + 1
for example in self.examples:
    der[i] = -self.dQbeta[example] 
    i = i + 1
for worker in self.workers:
    for example in self.examples:
        der[i] = self.dQgamma[worker][example] #VALUE ERROR HERE
        i = i + 1

return der

更新

如果我说self.dQgamma=defaultdict(lambda: defaultdict(der.dtype))，我会

NameError: global name 'der' is not defined

编辑

  def gradientQ(self, dtype):

        self.optimize_df(x)
        self.dQalpha={}
        self.dQbeta={}
        self.dQgamma=defaultdict(lambda: defaultdict(x.dtype)) 
        #ERROR TypeError: first argument must be callable

        for example, worker_label_set in self.e2wl.items():
            dQb = 0
            for (worker, label) in worker_label_set:
                for tlabel in self.prior.keys():
                    sigma = self.sigmoid(self.alpha[worker]*self.expbeta(self.beta[example]))
                    delta = self.kronecker_delta(label,tlabel)
                    dQb = dQb + self.e2lpd[example][tlabel]*(delta-sigma)*self.alpha[worker]*self.expbeta(self.beta[example])\
                          *self.expgamma(self.gamma[worker][example])
            self.dQbeta[example] = dQb - (self.beta[example] - self.priorbeta[example])

        for worker, example_label_set in self.w2el.items():
            dQa = 0
            for (example, label) in example_label_set:
                for tlabel in self.prior.keys():
                    sigma = self.sigmoid(self.alpha[worker]*self.expbeta(self.beta[example]))
                    delta = self.kronecker_delta(label,tlabel)
                    dQa = dQa + self.e2lpd[example][tlabel]*(delta-sigma)*self.expbeta(self.beta[example])\
                          *self.expgamma(self.gamma[worker][example])

            self.dQalpha[worker] = dQa - (self.alpha[worker] - self.prioralpha[worker])


        for worker, example_label_set in self.w2el.items():
            for example, worker_label_set in self.e2wl.items():
                dQg = 0
                for tlabel in self.prior.keys():
                    sigma = self.sigmoid(self.alpha[worker]*self.expbeta(self.beta[example])*\
                                         self.expgamma(self.gamma[worker][example]))
                    delta = self.kronecker_delta(label, tlabel)
                    dQg = dQg + self.e2lpd[example][tlabel]*(delta-sigma)*self.alpha[worker]*self.expbeta(self.beta[example])\
                          *self.expgamma(self.gamma[worker][example])

            self.dQgamma[worker][example] = dQg - (self.gamma[worker][example] - self.priorgamma[worker][example])

def optimize_df(self,x):
    # unpack x
    i=0
    for worker in self.workers:
        self.alpha[worker] = x[i]
        i = i + 1

    for example in self.examples:
        self.beta[example] = x[i]
        i = i + 1

    for worker in self.workers:
        for example in self.examples:
            self.gamma[worker][example] = x[i]
            i = i + 1


    self.gradientQ(x.dtype)

    # pack x
    der = np.zeros_like(x)
    i = 0
    for worker in self.workers:
        der[i] = -self.dQalpha[worker] #Flip the sign since we want to minimize
        i = i + 1
    for example in self.examples:
        der[i] = -self.dQbeta[example] #Flip the sign since we want to minimize
        i = i + 1
    for worker in self.workers:
        for example in self.examples:
            der[i]= self.dQgamma[worker][example] #Flip the sign since we want to minimize #TODO: fix
            i = i + 1
    return der

Answer 1

self.dQgamma[worker][example]返回的值是字典或列表（取决于您如何声明）

您试图将其影响到一个需要标量的numpy数组。 这就是你犯错误的原因

您应该声明dQgamma，使其为数组返回兼容的值：

self.dQgamma=defaultdict(lambda: defaultdict(der.dtype.type))

---

编辑

在所有下面的评论之后，我更新了我的答案

首先，实际上是一个^{} 对象不可调用，必须检索其^{} 可调用的属性。 所以我编辑了上面的代码块以匹配正确的语法

然后，下面是一个完整的示例，介绍如何在函数中使用数组类型（我更改了一些名称以匹配^{}约定）

from collections import defaultdict

import numpy as np

class MyClass:
    def gradient(self, dtype):
        self.d_qgamma=defaultdict(lambda: defaultdict(dtype.type))

        print("Unset first level value:", self.d_qgamma[0])
        print("Unset second level value:", self.d_qgamma[0][0])

        self.d_qgamma['a'] = defaultdict(dtype.type, {'z': dtype.type(42)})
        print("Set first level value:", self.d_qgamma['a'])

        self.d_qgamma['b']['a'] = dtype.type("42")
        print("Set second level value:", self.d_qgamma['b']['a'])

        print("d_qgamma:", self.d_qgamma)

    def optimize_df(self, x):
        self.gradient(x.dtype)

        der = np.zeros_like(x)
        der[0] = self.d_qgamma['b']['a']
        return der

if __name__ == '__main__':
    print("der:", MyClass().optimize_df(np.zeros(4, np.float32)))

Unset first level value: defaultdict(<class 'numpy.float32'>, {})
Unset second level value: 0.0
Set first level value: defaultdict(<class 'numpy.float32'>, {'z': 42.0})
Set second level value: 42.0
d_qgamma: defaultdict(<function MyClass.gradient.<locals>.<lambda> at 0x7fcfd1663050>, {0: defaultdict(<class 'numpy.float32'>, {0: 0.0}), 'a': defaultdict(<class 'numpy.float32'>, {'z': 42.0}), 'b': defaultdict(<class 'numpy.float32'>, {'a': 42.0})})
der: [42.  0.  0.  0.]

如您所见，您将类型numpy.dtype的x.dtype传递给gradient函数。 然后，您可以使用此dtype对象并检索其type属性（可调用），以：

• 将其传递给defaultdict构造函数

  self.d_qgamma=defaultdict(lambda: defaultdict(dtype.type))

• 铸造任何您想要存储的值

  self.d_qgamma['b']['a'] = dtype.type("42")

  这里，字符串"42"被转换为值为42.0的float。