mirror of
				https://github.com/explosion/spaCy.git
				synced 2025-11-01 08:27:44 +03:00 
			
		
		
		
	replace tags
This commit is contained in:
		
							parent
							
								
									91e0c3d782
								
							
						
					
					
						commit
						641609070f
					
				|  | @ -75,17 +75,17 @@ architectures and their arguments and hyperparameters. | |||
| > nlp.add_pipe("spancat_exclusive", config=config) | ||||
| > ``` | ||||
| 
 | ||||
| | Setting              | Description                                                                                                                                                                                                                                                                                                                | | ||||
| | -------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | ||||
| | `suggester`          | A function that [suggests spans](#suggesters). Spans are returned as a ragged array with two integer columns, for the start and end positions. Defaults to [`ngram_suggester`](#ngram_suggester). ~~Callable[[Iterable[Doc], Optional[Ops]], Ragged]~~                                                                     | | ||||
| | `model`              | A model instance that is given a a list of documents and `(start, end)` indices representing candidate span offsets. The model predicts a probability for each category for each span. Defaults to [SpanCategorizer](/api/architectures#SpanCategorizer). ~~Model[Tuple[List[Doc], Ragged], Floats2d]~~                    | | ||||
| | `spans_key`          | Key of the [`Doc.spans`](/api/doc#spans) dict to save the spans under. During initialization and training, the component will look for spans on the reference document under the same key. Defaults to `"sc"`. ~~str~~                                                                                                     | | ||||
| | `threshold`          | Minimum probability to consider a prediction positive. Spans with a positive prediction will be saved on the Doc. Meant to be used in combination with the multi-class `spancat` component with a `Logistic` scoring layer. Defaults to `0.5`. ~~float~~                                                                   | | ||||
| | `max_positive`       | Maximum number of labels to consider positive per span. Defaults to `None`, indicating no limit. Meant to be used together with the `spancat` component and defaults to 0 with `spancat_singlelabel`. ~~Optional[int]~~                                                                                                    | | ||||
| | `scorer`             | The scoring method. Defaults to [`Scorer.score_spans`](/api/scorer#score_spans) for `Doc.spans[spans_key]` with overlapping spans allowed. ~~Optional[Callable]~~                                                                                                                                                          | | ||||
| | `add_negative_label` | Whether to learn to predict a special negative label for each unannotated `Span` <Tag variant="new">3.5.1</Tag>. This should be `True` when using a `Softmax` classifier layer and so its `True` by default for `spancat_singlelabel`. Spans with negative labels and their scores are not stored as annotations. ~~bool~~ | | ||||
| | `negative_weight`    | Multiplier for the loss terms. It can be used to downweight the negative samples if there are too many <Tag variant="new">3.5.1</Tag>. It is only used when `add_negative_label` is `True`. Defaults to `1.0`. ~~float~~                                                                                                   | | ||||
| | `allow_overlap`      | If `True`, the data is assumed to contain overlapping spans. It is only available when `max_positive` is exactly 1 <Tag variant="new">3.5.1</Tag>. Defaults to `True`. ~~bool~~                                                                                                                                            | | ||||
| | Setting                                             | Description                                                                                                                                                                                                                                                                                             | | ||||
| | --------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | ||||
| | `suggester`                                         | A function that [suggests spans](#suggesters). Spans are returned as a ragged array with two integer columns, for the start and end positions. Defaults to [`ngram_suggester`](#ngram_suggester). ~~Callable[[Iterable[Doc], Optional[Ops]], Ragged]~~                                                  | | ||||
| | `model`                                             | A model instance that is given a a list of documents and `(start, end)` indices representing candidate span offsets. The model predicts a probability for each category for each span. Defaults to [SpanCategorizer](/api/architectures#SpanCategorizer). ~~Model[Tuple[List[Doc], Ragged], Floats2d]~~ | | ||||
| | `spans_key`                                         | Key of the [`Doc.spans`](/api/doc#spans) dict to save the spans under. During initialization and training, the component will look for spans on the reference document under the same key. Defaults to `"sc"`. ~~str~~                                                                                  | | ||||
| | `threshold`                                         | Minimum probability to consider a prediction positive. Spans with a positive prediction will be saved on the Doc. Meant to be used in combination with the multi-class `spancat` component with a `Logistic` scoring layer. Defaults to `0.5`. ~~float~~                                                | | ||||
| | `max_positive`                                      | Maximum number of labels to consider positive per span. Defaults to `None`, indicating no limit. Meant to be used together with the `spancat` component and defaults to 0 with `spancat_singlelabel`. ~~Optional[int]~~                                                                                 | | ||||
| | `scorer`                                            | The scoring method. Defaults to [`Scorer.score_spans`](/api/scorer#score_spans) for `Doc.spans[spans_key]` with overlapping spans allowed. ~~Optional[Callable]~~                                                                                                                                       | | ||||
| | `add_negative_label` <Tag variant="new">3.5.1</Tag> | Whether to learn to predict a special negative label for each unannotated `Span` . This should be `True` when using a `Softmax` classifier layer and so its `True` by default for `spancat_singlelabel`. Spans with negative labels and their scores are not stored as annotations. ~~bool~~            | | ||||
| | `negative_weight` <Tag variant="new">3.5.1</Tag>    | Multiplier for the loss terms. It can be used to downweight the negative samples if there are too many. It is only used when `add_negative_label` is `True`. Defaults to `1.0`. ~~float~~                                                                                                               | | ||||
| | `allow_overlap` <Tag variant="new">3.5.1</Tag>      | If `True`, the data is assumed to contain overlapping spans. It is only available when `max_positive` is exactly 1. Defaults to `True`. ~~bool~~                                                                                                                                                        | | ||||
| 
 | ||||
| ```python | ||||
| %%GITHUB_SPACY/spacy/pipeline/spancat.py | ||||
|  | @ -113,19 +113,19 @@ 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`              | A model instance that is given a a list of documents and `(start, end)` indices representing candidate span offsets. The model predicts a probability for each category for each span. ~~Model[Tuple[List[Doc], Ragged], Floats2d]~~                                                                                       | | ||||
| | `suggester`          | A function that [suggests spans](#suggesters). Spans are returned as a ragged array with two integer columns, for the start and end positions. ~~Callable[[Iterable[Doc], Optional[Ops]], Ragged]~~                                                                                                                        | | ||||
| | `name`               | String name of the component instance. Used to add entries to the `losses` during training. ~~str~~                                                                                                                                                                                                                        | | ||||
| | _keyword-only_       |                                                                                                                                                                                                                                                                                                                            | | ||||
| | `spans_key`          | Key of the [`Doc.spans`](/api/doc#sans) dict to save the spans under. During initialization and training, the component will look for spans on the reference document under the same key. Defaults to `"sc"`. ~~str~~                                                                                                      | | ||||
| | `threshold`          | Minimum probability to consider a prediction positive. Spans with a positive prediction will be saved on the Doc. Defaults to `0.5`. ~~float~~                                                                                                                                                                             | | ||||
| | `max_positive`       | Maximum number of labels to consider positive per span. Defaults to `None`, indicating no limit. ~~Optional[int]~~                                                                                                                                                                                                         | | ||||
| | `allow_overlap`      | If `True`, the data is assumed to contain overlapping spans. It is only available when `max_positive` is exactly 1 <Tag variant="new">3.5.1</Tag>. Defaults to `True`. ~~bool~~                                                                                                                                            | | ||||
| | `add_negative_label` | Whether to learn to predict a special negative label for each unannotated `Span`. This should be `True` when using a `Softmax` classifier layer and so its `True` by default for `spancat_singlelabel` <Tag variant="new">3.5.1</Tag>. Spans with negative labels and their scores are not stored as annotations. ~~bool~~ | | ||||
| | `negative_weight`    | Multiplier for the loss terms. It can be used to downweight the negative samples if there are too many <Tag variant="new">3.5.1</Tag>. It is only used when `add_negative_label` is `True`. Defaults to `1.0`. ~~float~~                                                                                                   | | ||||
| | Name                                                | Description                                                                                                                                                                                                                                                                                  | | ||||
| | --------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | ||||
| | `vocab`                                             | The shared vocabulary. ~~Vocab~~                                                                                                                                                                                                                                                             | | ||||
| | `model`                                             | A model instance that is given a a list of documents and `(start, end)` indices representing candidate span offsets. The model predicts a probability for each category for each span. ~~Model[Tuple[List[Doc], Ragged], Floats2d]~~                                                         | | ||||
| | `suggester`                                         | A function that [suggests spans](#suggesters). Spans are returned as a ragged array with two integer columns, for the start and end positions. ~~Callable[[Iterable[Doc], Optional[Ops]], Ragged]~~                                                                                          | | ||||
| | `name`                                              | String name of the component instance. Used to add entries to the `losses` during training. ~~str~~                                                                                                                                                                                          | | ||||
| | _keyword-only_                                      |                                                                                                                                                                                                                                                                                              | | ||||
| | `spans_key`                                         | Key of the [`Doc.spans`](/api/doc#sans) dict to save the spans under. During initialization and training, the component will look for spans on the reference document under the same key. Defaults to `"sc"`. ~~str~~                                                                        | | ||||
| | `threshold`                                         | Minimum probability to consider a prediction positive. Spans with a positive prediction will be saved on the Doc. Defaults to `0.5`. ~~float~~                                                                                                                                               | | ||||
| | `max_positive`                                      | Maximum number of labels to consider positive per span. Defaults to `None`, indicating no limit. ~~Optional[int]~~                                                                                                                                                                           | | ||||
| | `allow_overlap` <Tag variant="new">3.5.1</Tag>      | If `True`, the data is assumed to contain overlapping spans. It is only available when `max_positive` is exactly 1. Defaults to `True`. ~~bool~~                                                                                                                                             | | ||||
| | `add_negative_label` <Tag variant="new">3.5.1</Tag> | Whether to learn to predict a special negative label for each unannotated `Span`. This should be `True` when using a `Softmax` classifier layer and so its `True` by default for `spancat_singlelabel` . Spans with negative labels and their scores are not stored as annotations. ~~bool~~ | | ||||
| | `negative_weight` <Tag variant="new">3.5.1</Tag>    | Multiplier for the loss terms. It can be used to downweight the negative samples if there are too many . It is only used when `add_negative_label` is `True`. Defaults to `1.0`. ~~float~~                                                                                                   | | ||||
| 
 | ||||
| ## SpanCategorizer.\_\_call\_\_ {id="call",tag="method"} | ||||
| 
 | ||||
|  |  | |||
		Loading…
	
		Reference in New Issue
	
	Block a user