spaCy/spacy/tests/vocab_vectors/test_memory_zone.py

from spacy.vocab import Vocab


def test_memory_zone_no_insertion():
    vocab = Vocab()
    with vocab.memory_zone():
        pass
    lex = vocab["horse"]
    assert lex.text == "horse"


def test_memory_zone_insertion():
    vocab = Vocab()
    _ = vocab["dog"]
    assert "dog" in vocab
    assert "horse" not in vocab
    with vocab.memory_zone():
        lex = vocab["horse"]
        assert lex.text == "horse"
    assert "dog" in vocab
    assert "horse" not in vocab


def test_memory_zone_redundant_insertion():
    """Test that if we insert an already-existing word while
    in the memory zone, it stays persistent"""
    vocab = Vocab()
    _ = vocab["dog"]
    assert "dog" in vocab
    assert "horse" not in vocab
    with vocab.memory_zone():
        lex = vocab["horse"]
        assert lex.text == "horse"
        _ = vocab["dog"]
    assert "dog" in vocab
    assert "horse" not in vocab
Support 'memory zones' for user memory management (#13621) Add a context manage nlp.memory_zone(), which will begin memory_zone() blocks on the vocab, string store, and potentially other components. Example usage: ``` with nlp.memory_zone(): for text in nlp.pipe(texts): do_something(doc) # do_something(doc) <-- Invalid ``` Once the memory_zone() block expires, spaCy will free any shared resources that were allocated for the text-processing that occurred within the memory_zone. If you create Doc objects within a memory zone, it's invalid to access them once the memory zone is expired. The purpose of this is that spaCy creates and stores Lexeme objects in the Vocab that can be shared between multiple Doc objects. It also interns strings. Normally, spaCy can't know when all Doc objects using a Lexeme are out-of-scope, so new Lexemes accumulate in the vocab, causing memory pressure. Memory zones solve this problem by telling spaCy "okay none of the documents allocated within this block will be accessed again". This lets spaCy free all new Lexeme objects and other data that were created during the block. The mechanism is general, so memory_zone() context managers can be added to other components that could benefit from them, e.g. pipeline components. I experimented with adding memory zone support to the tokenizer as well, for its cache. However, this seems unnecessarily complicated. It makes more sense to just stick a limit on the cache size. This lets spaCy benefit from the efficiency advantage of the cache better, because we can maintain a (bounded) cache even if only small batches of documents are being processed. 2024-09-09 12:19:39 +03:00			`from spacy.vocab import Vocab`


			`def test_memory_zone_no_insertion():`
			`vocab = Vocab()`
			`with vocab.memory_zone():`
			`pass`
			`lex = vocab["horse"]`
			`assert lex.text == "horse"`


			`def test_memory_zone_insertion():`
			`vocab = Vocab()`
			`_ = vocab["dog"]`
			`assert "dog" in vocab`
			`assert "horse" not in vocab`
			`with vocab.memory_zone():`
			`lex = vocab["horse"]`
			`assert lex.text == "horse"`
			`assert "dog" in vocab`
			`assert "horse" not in vocab`


			`def test_memory_zone_redundant_insertion():`
			`"""Test that if we insert an already-existing word while`
			`in the memory zone, it stays persistent"""`
			`vocab = Vocab()`
			`_ = vocab["dog"]`
			`assert "dog" in vocab`
			`assert "horse" not in vocab`
			`with vocab.memory_zone():`
			`lex = vocab["horse"]`
			`assert lex.text == "horse"`
			`_ = vocab["dog"]`
			`assert "dog" in vocab`
			`assert "horse" not in vocab`