mirror of
https://github.com/explosion/spaCy.git
synced 2024-12-28 19:06:33 +03:00
520279ff7c
* `Tok2Vec`: Add `distill` method * `Tok2Vec`: Refactor `update` * Add `Tok2Vec.distill` test * Update `distill` signature to accept `Example`s instead of separate teacher and student docs * Add docs * Remove docstring * Update test * Remove `update` calls from test * Update `Tok2Vec.distill` docstring
365 lines
17 KiB
Plaintext
365 lines
17 KiB
Plaintext
---
|
|
title: Tok2Vec
|
|
source: spacy/pipeline/tok2vec.py
|
|
version: 3
|
|
teaser: null
|
|
api_base_class: /api/pipe
|
|
api_string_name: tok2vec
|
|
api_trainable: true
|
|
---
|
|
|
|
Apply a "token-to-vector" model and set its outputs in the `Doc.tensor`
|
|
attribute. This is mostly useful to **share a single subnetwork** between
|
|
multiple components, e.g. to have one embedding and CNN network shared between a
|
|
[`DependencyParser`](/api/dependencyparser), [`Tagger`](/api/tagger) and
|
|
[`EntityRecognizer`](/api/entityrecognizer).
|
|
|
|
In order to use the `Tok2Vec` predictions, subsequent components should use the
|
|
[Tok2VecListener](/api/architectures#Tok2VecListener) layer as the `tok2vec`
|
|
subnetwork of their model. This layer will read data from the `doc.tensor`
|
|
attribute during prediction. During training, the `Tok2Vec` component will save
|
|
its prediction and backprop callback for each batch, so that the subsequent
|
|
components can backpropagate to the shared weights. This implementation is used
|
|
because it allows us to avoid relying on object identity within the models to
|
|
achieve the parameter sharing.
|
|
|
|
## Config and implementation {id="config"}
|
|
|
|
The default config is defined by the pipeline component factory and describes
|
|
how the component should be configured. You can override its settings via the
|
|
`config` argument on [`nlp.add_pipe`](/api/language#add_pipe) or in your
|
|
[`config.cfg` for training](/usage/training#config). See the
|
|
[model architectures](/api/architectures) documentation for details on the
|
|
architectures and their arguments and hyperparameters.
|
|
|
|
> #### Example
|
|
>
|
|
> ```python
|
|
> from spacy.pipeline.tok2vec import DEFAULT_TOK2VEC_MODEL
|
|
> config = {"model": DEFAULT_TOK2VEC_MODEL}
|
|
> nlp.add_pipe("tok2vec", config=config)
|
|
> ```
|
|
|
|
| Setting | Description |
|
|
| ------- | ------------------------------------------------------------------------------------------------------------------ |
|
|
| `model` | The model to use. Defaults to [HashEmbedCNN](/api/architectures#HashEmbedCNN). ~~Model[List[Doc], List[Floats2d]~~ |
|
|
|
|
```python
|
|
%%GITHUB_SPACY/spacy/pipeline/tok2vec.py
|
|
```
|
|
|
|
## Tok2Vec.\_\_init\_\_ {id="init",tag="method"}
|
|
|
|
> #### Example
|
|
>
|
|
> ```python
|
|
> # Construction via add_pipe with default model
|
|
> tok2vec = nlp.add_pipe("tok2vec")
|
|
>
|
|
> # Construction via add_pipe with custom model
|
|
> config = {"model": {"@architectures": "my_tok2vec"}}
|
|
> parser = nlp.add_pipe("tok2vec", config=config)
|
|
>
|
|
> # Construction from class
|
|
> from spacy.pipeline import Tok2Vec
|
|
> tok2vec = Tok2Vec(nlp.vocab, model)
|
|
> ```
|
|
|
|
Create a new pipeline instance. In your application, you would normally use a
|
|
shortcut for this and instantiate the component using its string name and
|
|
[`nlp.add_pipe`](/api/language#create_pipe).
|
|
|
|
| Name | Description |
|
|
| ------- | ------------------------------------------------------------------------------------------------------------------------- |
|
|
| `vocab` | The shared vocabulary. ~~Vocab~~ |
|
|
| `model` | The Thinc [`Model`](https://thinc.ai/docs/api-model) powering the pipeline component. ~~Model[List[Doc], List[Floats2d]~~ |
|
|
| `name` | String name of the component instance. Used to add entries to the `losses` during training. ~~str~~ |
|
|
|
|
## Tok2Vec.\_\_call\_\_ {id="call",tag="method"}
|
|
|
|
Apply the pipe to one document and add context-sensitive embeddings to the
|
|
`Doc.tensor` attribute, allowing them to be used as features by downstream
|
|
components. The document is modified in place, and returned. This usually
|
|
happens under the hood when the `nlp` object is called on a text and all
|
|
pipeline components are applied to the `Doc` in order. Both
|
|
[`__call__`](/api/tok2vec#call) and [`pipe`](/api/tok2vec#pipe) delegate to the
|
|
[`predict`](/api/tok2vec#predict) and
|
|
[`set_annotations`](/api/tok2vec#set_annotations) methods.
|
|
|
|
> #### Example
|
|
>
|
|
> ```python
|
|
> doc = nlp("This is a sentence.")
|
|
> tok2vec = nlp.add_pipe("tok2vec")
|
|
> # This usually happens under the hood
|
|
> processed = tok2vec(doc)
|
|
> ```
|
|
|
|
| Name | Description |
|
|
| ----------- | -------------------------------- |
|
|
| `doc` | The document to process. ~~Doc~~ |
|
|
| **RETURNS** | The processed document. ~~Doc~~ |
|
|
|
|
## Tok2Vec.distill {id="distill", tag="method,experimental", version="4"}
|
|
|
|
Performs an update of the student pipe's model using the student's distillation
|
|
examples and sets the annotations of the teacher's distillation examples using
|
|
the teacher pipe.
|
|
|
|
Unlike other trainable pipes, the student pipe doesn't directly learn its
|
|
representations from the teacher. However, since downstream pipes that do
|
|
perform distillation expect the tok2vec annotations to be present on the
|
|
correct distillation examples, we need to ensure that they are set beforehand.
|
|
|
|
The distillation is performed on ~~Example~~ objects. The `Example.reference`
|
|
and `Example.predicted` ~~Doc~~s must have the same number of tokens and the
|
|
same orthography. Even though the reference does not need have to have gold
|
|
annotations, the teacher could adds its own annotations when necessary.
|
|
|
|
This feature is experimental.
|
|
|
|
> #### Example
|
|
>
|
|
> ```python
|
|
> teacher_pipe = teacher.add_pipe("tok2vec")
|
|
> student_pipe = student.add_pipe("tok2vec")
|
|
> optimizer = nlp.resume_training()
|
|
> losses = student.distill(teacher_pipe, examples, sgd=optimizer)
|
|
> ```
|
|
|
|
| Name | Description |
|
|
| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
|
|
| `teacher_pipe` | The teacher pipe to use for prediction. ~~Optional[TrainablePipe]~~ |
|
|
| `examples` | Distillation examples. The reference (teacher) and predicted (student) docs must have the same number of tokens and the same orthography. ~~Iterable[Example]~~ |
|
|
| _keyword-only_ | |
|
|
| `drop` | Dropout rate. ~~float~~ |
|
|
| `sgd` | An optimizer. Will be created via [`create_optimizer`](#create_optimizer) if not set. ~~Optional[Optimizer]~~ |
|
|
| `losses` | Optional record of the loss during distillation. Updated using the component name as the key. ~~Optional[Dict[str, float]]~~ |
|
|
| **RETURNS** | The updated `losses` dictionary. ~~Dict[str, float]~~ |
|
|
|
|
## Tok2Vec.pipe {id="pipe",tag="method"}
|
|
|
|
Apply the pipe to a stream of documents. This usually happens under the hood
|
|
when the `nlp` object is called on a text and all pipeline components are
|
|
applied to the `Doc` in order. Both [`__call__`](/api/tok2vec#call) and
|
|
[`pipe`](/api/tok2vec#pipe) delegate to the [`predict`](/api/tok2vec#predict)
|
|
and [`set_annotations`](/api/tok2vec#set_annotations) methods.
|
|
|
|
> #### Example
|
|
>
|
|
> ```python
|
|
> tok2vec = nlp.add_pipe("tok2vec")
|
|
> for doc in tok2vec.pipe(docs, batch_size=50):
|
|
> pass
|
|
> ```
|
|
|
|
| Name | Description |
|
|
| -------------- | ------------------------------------------------------------- |
|
|
| `stream` | A stream of documents. ~~Iterable[Doc]~~ |
|
|
| _keyword-only_ | |
|
|
| `batch_size` | The number of documents to buffer. Defaults to `128`. ~~int~~ |
|
|
| **YIELDS** | The processed documents in order. ~~Doc~~ |
|
|
|
|
## Tok2Vec.initialize {id="initialize",tag="method"}
|
|
|
|
Initialize the component for training and return an
|
|
[`Optimizer`](https://thinc.ai/docs/api-optimizers). `get_examples` should be a
|
|
function that returns an iterable of [`Example`](/api/example) objects. **At
|
|
least one example should be supplied.** The data examples are used to
|
|
**initialize the model** of the component and can either be the full training
|
|
data or a representative sample. Initialization includes validating the network,
|
|
[inferring missing shapes](https://thinc.ai/docs/usage-models#validation) and
|
|
setting up the label scheme based on the data. This method is typically called
|
|
by [`Language.initialize`](/api/language#initialize).
|
|
|
|
> #### Example
|
|
>
|
|
> ```python
|
|
> tok2vec = nlp.add_pipe("tok2vec")
|
|
> tok2vec.initialize(lambda: examples, nlp=nlp)
|
|
> ```
|
|
|
|
| Name | Description |
|
|
| -------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
|
| `get_examples` | Function that returns gold-standard annotations in the form of [`Example`](/api/example) objects. Must contain at least one `Example`. ~~Callable[[], Iterable[Example]]~~ |
|
|
| _keyword-only_ | |
|
|
| `nlp` | The current `nlp` object. Defaults to `None`. ~~Optional[Language]~~ |
|
|
|
|
## Tok2Vec.predict {id="predict",tag="method"}
|
|
|
|
Apply the component's model to a batch of [`Doc`](/api/doc) objects without
|
|
modifying them.
|
|
|
|
> #### Example
|
|
>
|
|
> ```python
|
|
> tok2vec = nlp.add_pipe("tok2vec")
|
|
> scores = tok2vec.predict([doc1, doc2])
|
|
> ```
|
|
|
|
| Name | Description |
|
|
| ----------- | ------------------------------------------- |
|
|
| `docs` | The documents to predict. ~~Iterable[Doc]~~ |
|
|
| **RETURNS** | The model's prediction for each document. |
|
|
|
|
## Tok2Vec.set_annotations {id="set_annotations",tag="method"}
|
|
|
|
Modify a batch of [`Doc`](/api/doc) objects, using pre-computed scores.
|
|
|
|
> #### Example
|
|
>
|
|
> ```python
|
|
> tok2vec = nlp.add_pipe("tok2vec")
|
|
> scores = tok2vec.predict(docs)
|
|
> tok2vec.set_annotations(docs, scores)
|
|
> ```
|
|
|
|
| Name | Description |
|
|
| -------- | ------------------------------------------------- |
|
|
| `docs` | The documents to modify. ~~Iterable[Doc]~~ |
|
|
| `scores` | The scores to set, produced by `Tok2Vec.predict`. |
|
|
|
|
## Tok2Vec.update {id="update",tag="method"}
|
|
|
|
Learn from a batch of [`Example`](/api/example) objects containing the
|
|
predictions and gold-standard annotations, and update the component's model.
|
|
Delegates to [`predict`](/api/tok2vec#predict).
|
|
|
|
> #### Example
|
|
>
|
|
> ```python
|
|
> tok2vec = nlp.add_pipe("tok2vec")
|
|
> optimizer = nlp.initialize()
|
|
> losses = tok2vec.update(examples, sgd=optimizer)
|
|
> ```
|
|
|
|
| Name | Description |
|
|
| -------------- | ------------------------------------------------------------------------------------------------------------------------ |
|
|
| `examples` | A batch of [`Example`](/api/example) objects to learn from. ~~Iterable[Example]~~ |
|
|
| _keyword-only_ | |
|
|
| `drop` | The dropout rate. ~~float~~ |
|
|
| `sgd` | An optimizer. Will be created via [`create_optimizer`](#create_optimizer) if not set. ~~Optional[Optimizer]~~ |
|
|
| `losses` | Optional record of the loss during training. Updated using the component name as the key. ~~Optional[Dict[str, float]]~~ |
|
|
| **RETURNS** | The updated `losses` dictionary. ~~Dict[str, float]~~ |
|
|
|
|
## Tok2Vec.create_optimizer {id="create_optimizer",tag="method"}
|
|
|
|
Create an optimizer for the pipeline component.
|
|
|
|
> #### Example
|
|
>
|
|
> ```python
|
|
> tok2vec = nlp.add_pipe("tok2vec")
|
|
> optimizer = tok2vec.create_optimizer()
|
|
> ```
|
|
|
|
| Name | Description |
|
|
| ----------- | ---------------------------- |
|
|
| **RETURNS** | The optimizer. ~~Optimizer~~ |
|
|
|
|
## Tok2Vec.use_params {id="use_params",tag="method, contextmanager"}
|
|
|
|
Modify the pipe's model to use the given parameter values. At the end of the
|
|
context, the original parameters are restored.
|
|
|
|
> #### Example
|
|
>
|
|
> ```python
|
|
> tok2vec = nlp.add_pipe("tok2vec")
|
|
> with tok2vec.use_params(optimizer.averages):
|
|
> tok2vec.to_disk("/best_model")
|
|
> ```
|
|
|
|
| Name | Description |
|
|
| -------- | -------------------------------------------------- |
|
|
| `params` | The parameter values to use in the model. ~~dict~~ |
|
|
|
|
## Tok2Vec.to_disk {id="to_disk",tag="method"}
|
|
|
|
Serialize the pipe to disk.
|
|
|
|
> #### Example
|
|
>
|
|
> ```python
|
|
> tok2vec = nlp.add_pipe("tok2vec")
|
|
> tok2vec.to_disk("/path/to/tok2vec")
|
|
> ```
|
|
|
|
| Name | Description |
|
|
| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
|
|
| `path` | A path to a directory, which will be created if it doesn't exist. Paths may be either strings or `Path`-like objects. ~~Union[str, Path]~~ |
|
|
| _keyword-only_ | |
|
|
| `exclude` | String names of [serialization fields](#serialization-fields) to exclude. ~~Iterable[str]~~ |
|
|
|
|
## Tok2Vec.from_disk {id="from_disk",tag="method"}
|
|
|
|
Load the pipe from disk. Modifies the object in place and returns it.
|
|
|
|
> #### Example
|
|
>
|
|
> ```python
|
|
> tok2vec = nlp.add_pipe("tok2vec")
|
|
> tok2vec.from_disk("/path/to/tok2vec")
|
|
> ```
|
|
|
|
| Name | Description |
|
|
| -------------- | ----------------------------------------------------------------------------------------------- |
|
|
| `path` | A path to a directory. Paths may be either strings or `Path`-like objects. ~~Union[str, Path]~~ |
|
|
| _keyword-only_ | |
|
|
| `exclude` | String names of [serialization fields](#serialization-fields) to exclude. ~~Iterable[str]~~ |
|
|
| **RETURNS** | The modified `Tok2Vec` object. ~~Tok2Vec~~ |
|
|
|
|
## Tok2Vec.to_bytes {id="to_bytes",tag="method"}
|
|
|
|
> #### Example
|
|
>
|
|
> ```python
|
|
> tok2vec = nlp.add_pipe("tok2vec")
|
|
> tok2vec_bytes = tok2vec.to_bytes()
|
|
> ```
|
|
|
|
Serialize the pipe to a bytestring.
|
|
|
|
| Name | Description |
|
|
| -------------- | ------------------------------------------------------------------------------------------- |
|
|
| _keyword-only_ | |
|
|
| `exclude` | String names of [serialization fields](#serialization-fields) to exclude. ~~Iterable[str]~~ |
|
|
| **RETURNS** | The serialized form of the `Tok2Vec` object. ~~bytes~~ |
|
|
|
|
## Tok2Vec.from_bytes {id="from_bytes",tag="method"}
|
|
|
|
Load the pipe from a bytestring. Modifies the object in place and returns it.
|
|
|
|
> #### Example
|
|
>
|
|
> ```python
|
|
> tok2vec_bytes = tok2vec.to_bytes()
|
|
> tok2vec = nlp.add_pipe("tok2vec")
|
|
> tok2vec.from_bytes(tok2vec_bytes)
|
|
> ```
|
|
|
|
| Name | Description |
|
|
| -------------- | ------------------------------------------------------------------------------------------- |
|
|
| `bytes_data` | The data to load from. ~~bytes~~ |
|
|
| _keyword-only_ | |
|
|
| `exclude` | String names of [serialization fields](#serialization-fields) to exclude. ~~Iterable[str]~~ |
|
|
| **RETURNS** | The `Tok2Vec` object. ~~Tok2Vec~~ |
|
|
|
|
## Serialization fields {id="serialization-fields"}
|
|
|
|
During serialization, spaCy will export several data fields used to restore
|
|
different aspects of the object. If needed, you can exclude them from
|
|
serialization by passing in the string names via the `exclude` argument.
|
|
|
|
> #### Example
|
|
>
|
|
> ```python
|
|
> data = tok2vec.to_disk("/path", exclude=["vocab"])
|
|
> ```
|
|
|
|
| Name | Description |
|
|
| ------- | -------------------------------------------------------------- |
|
|
| `vocab` | The shared [`Vocab`](/api/vocab). |
|
|
| `cfg` | The config file. You usually don't want to exclude this. |
|
|
| `model` | The binary model data. You usually don't want to exclude this. |
|