4

我正在使用以下代码和嵌套生成器来迭代文本文档并使用get_train_minibatch(). 我想保留（腌制）生成器，这样我就可以回到文本文档中的同一位置。但是，您不能腌制生成器。

  • 是否有一个简单的解决方法，以便我可以保存我的位置并从我停止的地方重新开始？也许我可以做get_train_example()一个单例，所以我周围没有几个发电机。然后，我可以在这个模块中创建一个全局变量来跟踪距离get_train_example()。

  • 你有更好（更清洁）的建议，让我坚持这个生成器吗？

[编辑：还有两个想法：

  • 我可以向生成器添加一个成员变量/方法，这样我就可以调用 generator.tell() 并找到文件位置吗？因为那样，下次我创建生成器时，我可以要求它寻找那个位置。这个想法听起来是最简单的。

  • 我可以创建一个类并将文件位置作为成员变量，然后在类中创建生成器并在每次生成时更新文件位置成员变量吗？因为那时我可以知道它进入文件有多远。

]

这是代码：

def get_train_example():
    for l in open(HYPERPARAMETERS["TRAIN_SENTENCES"]):
        prevwords = []
        for w in string.split(l):
            w = string.strip(w)
            id = None
            prevwords.append(wordmap.id(w))
            if len(prevwords) >= HYPERPARAMETERS["WINDOW_SIZE"]:
                yield prevwords[-HYPERPARAMETERS["WINDOW_SIZE"]:]

def get_train_minibatch():
    minibatch = []
    for e in get_train_example():
        minibatch.append(e)
        if len(minibatch) >= HYPERPARAMETERS["MINIBATCH SIZE"]:
            assert len(minibatch) == HYPERPARAMETERS["MINIBATCH SIZE"]
            yield minibatch
            minibatch = []
4

6 回答 6

2

你可以创建一个标准的迭代器对象，只是不如生成器方便；您需要将迭代器的状态存储在实例上（以便对其进行腌制），并定义一个 next() 函数以返回下一个对象：

class TrainExampleIterator (object):
    def __init__(self):
        # set up internal state here
        pass
    def next(self):
        # return next item here
        pass

迭代器协议就这么简单，只需在对象上定义.next()方法，就可以将其传递给 for 循环等。

在 Python 3 中，迭代器协议__next__改为使用该方法（更一致）。

于 2009-12-21T11:09:34.837 回答
2

下面的代码应该或多或少地做你想要的。第一个类定义了一些类似于文件但可以腌制的东西。（当你解开它时，它会重新打开文件，并寻找你腌制它时的位置）。第二类是生成单词窗口的迭代器。

class PickleableFile(object):
    def __init__(self, filename, mode='rb'):
        self.filename = filename
        self.mode = mode
        self.file = open(filename, mode)
    def __getstate__(self):
        state = dict(filename=self.filename, mode=self.mode,
                     closed=self.file.closed)
        if not self.file.closed:
            state['filepos'] = self.file.tell()
        return state
    def __setstate__(self, state):
        self.filename = state['filename']
        self.mode = state['mode']
        self.file = open(self.filename, self.mode)
        if state['closed']: self.file.close()
        else: self.file.seek(state['filepos'])
    def __getattr__(self, attr):
        return getattr(self.file, attr)

class WordWindowReader:
    def __init__(self, filenames, window_size):
        self.filenames = filenames
        self.window_size = window_size
        self.filenum = 0
        self.stream = None
        self.filepos = 0
        self.prevwords = []
        self.current_line = []

    def __iter__(self):
        return self

    def next(self):
        # Read through files until we have a non-empty current line.
        while not self.current_line:
            if self.stream is None:
                if self.filenum >= len(self.filenames):
                    raise StopIteration
                else:
                    self.stream = PickleableFile(self.filenames[self.filenum])
                    self.stream.seek(self.filepos)
                    self.prevwords = []
            line = self.stream.readline()
            self.filepos = self.stream.tell()
            if line == '':
                # End of file.
                self.stream = None
                self.filenum += 1
                self.filepos = 0
            else:
                # Reverse line so we can pop off words.
                self.current_line = line.split()[::-1]

        # Get the first word of the current line, and add it to
        # prevwords.  Truncate prevwords when necessary.
        word = self.current_line.pop()
        self.prevwords.append(word)
        if len(self.prevwords) > self.window_size:
            self.prevwords = self.prevwords[-self.window_size:]

        # If we have enough words, then return a word window;
        # otherwise, go on to the next word.
        if len(self.prevwords) == self.window_size:
            return self.prevwords
        else:
            return self.next()
于 2009-12-21T18:11:33.577 回答
0

这可能不是您的选择，但 Stackless Python ( http://stackless.com )确实允许您在某些条件下腌制函数和生成器之类的东西。这将起作用：

在 foo.py 中：

def foo():
    with open('foo.txt') as fi:
        buffer = fi.read()
    del fi
    for line in buffer.split('\n'):
        yield line

在 foo.txt 中：

line1
line2
line3
line4
line5

在解释器中：

Python 2.6 Stackless 3.1b3 060516 (python-2.6:66737:66749M, Oct  2 2008, 18:31:31) 
IPython 0.9.1 -- An enhanced Interactive Python.

In [1]: import foo

In [2]: g = foo.foo()

In [3]: g.next()
Out[3]: 'line1'

In [4]: import pickle

In [5]: p = pickle.dumps(g)

In [6]: g2 = pickle.loads(p)

In [7]: g2.next()
Out[7]: 'line2'

一些需要注意的事情：你必须缓冲文件的内容，并删除文件对象。这意味着文件的内容将在泡菜中重复。

于 2009-12-21T17:34:21.047 回答
0

你也可以考虑使用 NLTK 的语料库阅读器：

-爱德华

于 2009-12-21T18:15:51.853 回答
0
  1. 将生成器转换为以生成器代码为__iter__方法的类
  2. 向类添加__getstate__和__setstate__方法，以处理酸洗。请记住，您不能腌制文件对象。因此__setstate__，必须根据需要重新打开文件。

我在此处使用示例代码更深入地描述了此方法。

于 2009-12-22T08:57:16.403 回答
-1

您可以尝试创建可调用对象： 

class TrainExampleGenerator:

    def __call__(self):
        for l in open(HYPERPARAMETERS["TRAIN_SENTENCES"]):
            prevwords = []
            for w in string.split(l):
                w = string.strip(w)
                id = None
                prevwords.append(wordmap.id(w))
                if len(prevwords) >= HYPERPARAMETERS["WINDOW_SIZE"]:
                    yield prevwords[-HYPERPARAMETERS["WINDOW_SIZE"]:]

get_train_example = TrainExampleGenerator()

现在您可以将所有需要保存的状态转换为对象字段并将它们公开给pickle。这是一个基本的想法，我希望这会有所帮助，但我自己还没有尝试过。

更新：
不幸的是，我没有表达我的想法。提供的示例不是完整的解决方案。你看，TrainExampleGenerator没有状态。您必须设计此状态并使其可用于酸洗。并且__call__方法应该使用和修改该状态，以便返回从对象状态确定的位置开始的生成器。显然，生成器本身不能腌制。但是TrainExampleGenerator可以腌制，您将能够用它重新创建生成器，就像生成器本身被腌制一样。

于 2009-12-21T09:33:08.837 回答