Question

我在class Input中定义了这个Model.py，现在在同一个文件中我有另一个类和一个单独的函数，在这两个函数中我调用了class Input。

在Model.py我有2个班级 - MLP和Input以及一个单独的function iter_minibatches。在类MLP中，我使用此语句Inp = Input(traindata).X，它返回一个二维数组（例如5000 * 2100）。然后在另一个模块base.py中，我调用function iter_minibatches我希望将Inp的相同值作为输入传递给函数（iter_minibatches），或者我希望得到相同的值在函数的开头（iter_minibatches）分配，所以我尝试在iter_minibatches中调用同一个类，但由于我使用随机函数进行排列，我得到不同的输出（例如5000 * 2102），但我的要求是得到iter_minibatches函数中的值相同。

现在我希望从这两个调用中返回相同的 X 值。那我怎么能这样做呢？

class Input(object):
    def __init__(self, X):
        self.step  = 1.0
        self.noise = 1.0
        self.triuind = (np.arange(23)[:,np.newaxis] <= np.arange(23)[np.newaxis,:]).flatten()
        self.max = 0
        for _ in range(10): self.max = np.maximum(self.max,self.realize(X).max(axis=0))
        X = self.expand(self.realize(X))
        X.append(X)
        self.nbout = X.shape[1]
        self.mean = X.mean(axis=0)
        self.std = (X - self.mean).std()
        self.X = X

    def realize(self,X):
        def _realize_(x):
            inds = np.argsort(-(x**2).sum(axis=0)**.5+np.random.normal(0,self.noise,x[0].shape))
            x = x[inds,:][:,inds]*1
            x = x.flatten()[self.triuind]
            return x
        return np.array([_realize_(z) for z in X])

    def expand(self,X):
        Xexp = []
        for i in range(X.shape[1]):
            for k in np.arange(0,self.max[i]+self.step,self.step):
                Xexp += [np.tanh((X[:, i]-k)/self.step)]

        return np.array(Xexp).T

Answer 1

您的问题似乎主要是关于如何在位于不同模块中的多个功能之间共享数据。有两种很好的方法可以解决这个问题：

首先，您可以将数据存储在全局变量中，并在需要时随时访问它。例如：

# top level code of module1.py
inp_x = Input(traindata).X  # I'm assuming traindata is also a global

# later code in the same module
do_stuff(inp_x)

# code in other modules can do:
import module1
do_other_stuff(module1.inp_x)  # a module's global variables are attributes on the module

第二个选项是在程序的某个特定部分创建数据并将其存储在本地，然后将其传递给您需要使用它的其他每个位置。这使您可以在代码中使用更通用的结构，并且可以在不同的时间传递不同的值。这可能是这样的：

# functions that use an X value:
def func1(arg1, arg2, X):
    do_stuff(X)

def func2(X):
    do_other_stuff(X)

# main module (or wherever you call func1 and func2 from)
from module1 import func1
from module2 import func2

def main():
    x = Input(traindata).X
    func1("foo", "bar", x)
    func2(x)

在这些示例中，我只保存（或作为参数传递）在X类中计算的Input值，这似乎是您的方式＆＃ 39;再次使用该课程。

这有点傻。如果您不需要保留Input的实例，那么您可能不应该首先使Input成为一个类。相反，使它成为一个在结尾返回X值的函数。您将在realize和expand函数之间传递更多参数，但代码可能会更整洁。

另一方面，如果Input的实例有其他一些用途（您的示例中没有显示），那么保存您正在创建的实例可能会有意义而不是X属性：

inp = Input(traindata)  # save the Input instance, not only X

# later code:
do_stuff(inp.X)  # use the X attribute, as above

# other code
do_other_stuff(inp)  # pass the instance, so you can use other attributes or methods

具有相同输出的多类调用

1 个答案: