INTUIA/Programa final/spacy/pipeline/__pycache__/spancat.cpython-312.pyc

Ë
>û gcxãóx—dd
lm
Z

ddlmZ
ddlmZmZmZmZm	Z	m
Z
mZmZm
Z

ddlZddlmZmZmZmZmZmZ
ddlmZmZmZmZ
ddlmZmZ
dd	lmZ
dd
l m!Z!
ddl"m#Z#
ddl$m%Z%m&Z&m'Z'
dd
l(m)Z)m*Z*
ddl+m,Z,
ddl-m.Z.
ddl/m0Z0
dZ1dZ2dZ3e«jie1«
dZ5e«jie2«
dZ6eGd„de««Z7ddœ
dee%de	e8de
edefd„Z9ddœ
dee%de:de
edefd„Z;e,jxd «
de	e8de7fd!„«Z=e,jxd"«
d#e8d$e8de7fd%„«Z>e,jxd&«
de:de7fd'„«Z?e!j€d(d)g
d*e3de5d gd+¢
d,œd-d.i
d/œd0d1d1d2œ¬3«d4e!d5e:d6e7deee	e%efefde:d7e
ed8eAd9e
e8dd:fd;„«ZBe!j€d<d)g
e3e6d0d gd+¢
d,œd-d.i
d=d>œd0d1d1d2œ¬3«d4e!d5e:d6e7deee	e%efefde:d?eAd@eCd7e
edd:fdA„«ZDdBee)dee:effdC„ZEe,jŒd.«
dD„«ZGe
GdE„dF««ZHGdG„d:e0«ZIy)Hé)
Ú	dataclass)
Úpartial)	ÚAnyÚCallableÚDictÚIterableÚListÚOptionalÚTupleÚUnionÚcastN)ÚConfigÚModelÚOpsÚ	OptimizerÚget_current_opsÚset_dropout_rate)ÚFloats2dÚInts1dÚInts2dÚRaggedé)ÚProtocolÚruntime_checkable)
ÚErrors)
ÚLanguage)
ÚScorer)ÚDocÚSpanÚ	SpanGroup)ÚExampleÚvalidate_examples)
Úregistry)
ÚVocabé
)
Ú
TrainablePipea4
[model]
@architectures = "spacy.SpanCategorizer.v1"
scorer = {"@layers": "spacy.LinearLogistic.v1"}

[model.reducer]
@layers = spacy.mean_max_reducer.v1
hidden_size = 128

[model.tok2vec]
@architectures = "spacy.Tok2Vec.v2"

[model.tok2vec.embed]
@architectures = "spacy.MultiHashEmbed.v2"
width = 96
rows = [5000, 1000, 2500, 1000]
attrs = ["NORM", "PREFIX", "SUFFIX", "SHAPE"]
include_static_vectors = false

[model.tok2vec.encode]
@architectures = "spacy.MaxoutWindowEncoder.v2"
width = ${model.tok2vec.embed.width}
window_size = 1
maxout_pieces = 3
depth = 4
a&
[model]
@architectures = "spacy.SpanCategorizer.v1"
scorer = {"@layers": "Softmax.v2"}

[model.reducer]
@layers = spacy.mean_max_reducer.v1
hidden_size = 128

[model.tok2vec]
@architectures = "spacy.Tok2Vec.v2"
[model.tok2vec.embed]
@architectures = "spacy.MultiHashEmbed.v1"
width = 96
rows = [5000, 1000, 2500, 1000]
attrs = ["NORM", "PREFIX", "SUFFIX", "SHAPE"]
include_static_vectors = false

[model.tok2vec.encode]
@architectures = "spacy.MaxoutWindowEncoder.v2"
width = ${model.tok2vec.embed.width}
window_size = 1
maxout_pieces = 3
depth = 4
ÚscÚmodelcó2—eZ
dZd
dœ
deedeedefd„Zy
)Ú	SuggesterN©
ÚopsÚdocsr,Úreturnc
ó—y©
N©)Úselfr-r,s   úWC:\Users\garci\AppData\Roaming\Python\Python312\site-packages\spacy/pipeline/spancat.pyÚ__call__zSuggester.__call__Qs€Øó)	Ú__name__Ú
__module__Ú__qualname__rrr
rrr4r1r5r3r*r*Os'„àDHò
˜X c™]ð
°H¸S±Mð
ÈVô
r5r*r+r-Úsizesr,r.c
	ó—|€
t
«}g}g}|D]â}|jjt|«
d
¬«}|j	d«
}d}|
D]‘}|t|«
krX|dt|«
|dz
z
}	|j|jj
|	|	|zf«
«

||djdz
}|s
Œl|djdk(r
ŒJ|dj«‚
|j|«

Œä|j|«
}
t|«
dkDr&t|jj|«
|
«}n't|jjdd
¬«|
«}|jjdk(sJ‚
|S)	NÚ
i©
Údtype)éÿÿÿÿr%rr%r>r©rr)rÚxpÚarangeÚlenÚreshapeÚappendÚhstackÚshapeÚndimÚ	asarray1irÚvstackÚzerosÚdataXd)r-r9r,ÚspansÚlengthsÚdocÚstartsÚlengthÚsizeÚstarts_sizeÚ
lengths_arrayÚoutputs            r3Úngram_suggesterrUUs^
€ð€{ÜÓˆØ€EØ€Gۈؗ‘—‘œs 3›x¨s�Ó3ˆØ—‘ Ó(ˆØˆÛˆDØ”s˜3“xÒØ$Ð%<¤s¨3£x°4¸!±8Ñ'<Ð=�Ø—‘˜SŸV™VŸ]™]¨K¸ÀtÑ9KÐ+LÓMÔNؘ% ™)Ÿ/™/¨!Ñ,Ñ,�ÚؘR‘y—~‘~¨Ó*Ð;¨E°"©I¯O©OÓ;Ð*ð
ð	�‰�vÕðð—M‘M 'Ó*€MÜ
ˆ5ƒz�A‚~ܘŸ™Ÿ
™
 eÓ,¨mÓ<‰ä˜Ÿ™Ÿ™ V°3˜Ó7¸ÓGˆà�=‰=×Ñ Ò"Ð"Ð"Ø€Mr5Ú	spans_keyc
óâ
—|€
t
«}g}g}|D]d}d
}|j|
r@|j|
D].}|j|j|jg«

|dz
}Œ0|j|«

Œftt|j|d¬««}t|«
d
kDrt|j|d¬«|«}	|	St|jjdd¬«|«}	|	S)Nrr%r;r<r?)rrLrDÚstartÚendr
rÚasarrayrBrr@rJ)
r-rVr,rLrMrNrPÚspanrSrTs
          r3Úpreset_spans_suggesterr\rsã€ð€{ÜÓˆØ€EØ€Gۈ؈Ø�9‰9�YÒØŸ	™	 )Ô,�Ø—‘˜dŸj™j¨$¯(©(Ð3Ô4ؘ!‘‘ð-ð	�‰�vÕðôœ §¡¨W¸C Ó!@ÓA€MÜ
ˆ5ƒz�A‚~ܘŸ™ E°˜Ó5°}ÓEˆð€Mô˜Ÿ™Ÿ™ V°3˜Ó7¸ÓGˆØ€Mr5zspacy.ngram_suggester.v1c
ó$—t
t|¬
«S)z£Suggest all spans of the given lengths. Spans are returned as a ragged
    array of integers. The array has two columns, indicating the start and end
    position.©
r9)rrUr^s
 r3Úbuild_ngram_suggesterr_‰s€ô”?¨%Ô0Ð0r5zspacy.ngram_range_suggester.v1Úmin_sizeÚmax_sizecóH—t
t||
d
z««
}t|«
S)zÖSuggest all spans of the given lengths between a given min and max value - both inclusive.
    Spans are returned as a ragged array of integers. The array has two columns,
    indicating the start and end position.r%)ÚlistÚranger_)r`rar9s   r3Úbuild_ngram_range_suggesterre’s$€ô

”�x ¨A¡Ó.Ó/€EÜ  Ó'Ð'r5zspacy.preset_spans_suggester.v1c
ó$—t
t|¬
«S)z»Suggest all spans that are already stored in doc.spans[spans_key].
    This is useful when an upstream component is used to set the spans
    on the Doc such as a SpanRuler or SpanFinder.©
rV)rr\rgs
 r3Úbuild_preset_spans_suggesterrh›s€ô
Ô)°YÔ?Ð?r5Úspancatz	doc.spansçà?)r%ré)z@miscr9z@scorerszspacy.spancat_scorer.v1)Ú	thresholdrVÚmax_positiver(Ú	suggesterÚscorerçð?ç)Ú
spans_sc_fÚ
spans_sc_pÚ
spans_sc_r)ÚassignsÚdefault_configÚdefault_score_weightsÚnlpÚnamernrorlrmÚSpanCategorizerc
óB—t
|j|||
|d
d|||d¬«S)aCreate a SpanCategorizer component and configure it for multi-label
    classification to be able to assign multiple labels for each span.
    The span categorizer consists of two
    parts: a suggester function that proposes candidate spans, and a labeller
    model that predicts one or more labels for each span.

    name (str): The component instance name, used to add entries to the
        losses during training.
    suggester (Callable[[Iterable[Doc], Optional[Ops]], Ragged]): A function that suggests spans.
        Spans are returned as a ragged array with two integer columns, for the
        start and end positions.
    model (Model[Tuple[List[Doc], Ragged], Floats2d]): A model instance that
        is given a list of documents and (start, end) indices representing
        candidate span offsets. The model predicts a probability for each category
        for each span.
    spans_key (str): Key of the 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.
    scorer (Optional[Callable]): The scoring method. Defaults to
        Scorer.score_spans for the Doc.spans[spans_key] with overlapping
        spans allowed.
    threshold (float): Minimum probability to consider a prediction positive.
        Spans with a positive prediction will be saved on the Doc. Defaults to
        0.5.
    max_positive (Optional[int]): Maximum number of labels to consider positive
        per span. Defaults to None, indicating no limit.
    NTF)
r(rnryrVÚnegative_weightÚ
allow_overlaprmrlroÚadd_negative_label©rzÚvocab)rxryrnr(rVrorlrms        r3Úmake_spancatr�£s7€ôd
Ø�	‰	ØØØ
ØØØØ!ØØØ ôðr5Úspancat_singlelabelT)rVr(r|rnror}r|r}c
óB—t
|j|||
|||d
dd|¬«S)aBCreate a SpanCategorizer component and configure it for multi-class
    classification. With this configuration each span can get at most one
    label. The span categorizer consists of two
    parts: a suggester function that proposes candidate spans, and a labeller
    model that predicts one or more labels for each span.

    name (str): The component instance name, used to add entries to the
        losses during training.
    suggester (Callable[[Iterable[Doc], Optional[Ops]], Ragged]): A function that suggests spans.
        Spans are returned as a ragged array with two integer columns, for the
        start and end positions.
    model (Model[Tuple[List[Doc], Ragged], Floats2d]): A model instance that
        is given a list of documents and (start, end) indices representing
        candidate span offsets. The model predicts a probability for each category
        for each span.
    spans_key (str): Key of the 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.
    scorer (Optional[Callable]): The scoring method. Defaults to
        Scorer.score_spans for the Doc.spans[spans_key] with overlapping
        spans allowed.
    negative_weight (float): Multiplier for the loss terms.
        Can be used to downweight the negative samples if there are too many.
    allow_overlap (bool): If True the data is assumed to contain overlapping spans.
        Otherwise it produces non-overlapping spans greedily prioritizing
        higher assigned label scores.
    r%TN)
r(rnryrVr|r}rmr~rlror)rxryrnr(rVr|r}ros        r3Úmake_spancat_singlelabelr„äs7€ôd
Ø�	‰	ØØØ
ØØ'Ø#ØØØØôðr5Úexamplesc
óú‡‡—t
|
«
}
d
Š|
dŠ|
jd‰›‰›�«
|
jdd«
|
jdˆf
d„«
|
jdˆf
d	„«
tj|f
i|
¤
Ž
S)
NÚspans_rVÚattrr}TÚgettercóT•
—|jj|
t‰«
dg«Sr0)rLÚgetrB)rNÚkeyÚattr_prefixs  €r3ú<lambda>zspancat_score.<locals>.<lambda>,
s!ø€ 3§9¡9§=¡=°´S¸Ó5EÐ5GÐ1HÈ"Ô#Mr5Úhas_annotationc
ó •
—‰
|jvSr0)
rL)rNrŒs €r3rŽzspancat_score.<locals>.<lambda>.
sø€°C¸3¿9¹9Ñ4Dr5)ÚdictÚ
setdefaultrÚscore_spans)r…Úkwargsr�rŒs  @@r3Ú
spancat_scorer•%
s‚ù€Ü
�&‹\€FØ€KØ
�Ñ
€CØ
×Ñ�f  
¨c¨UÐ3Ô4Ø
×Ñ�o tÔ,Ø
×ÑØÓMôð×ÑÐ&Ó(DÔEÜ×јhÑ1¨&Ñ1Ð1r5c
ó—tSr0)
r•r1r5r3Úmake_spancat_scorerr—2
s€äÐr5c
ó"—eZ
dZd
Zd„Zd„Zd„Zy)Ú
_Intervalsz:
    Helper class to avoid storing overlapping spans.
    c
ó"—t
«|_
yr0)ÚsetÚranges©
r2s
 r3Ú__init__z_Intervals.__init__=
s€Ü“eˆ�r5có\—t
|
|«D]}|jj|«

Œyr0)rdrœÚadd)r2r;Ú
jÚ
es    r3r z_Intervals.add@
s"€Ü�q˜!–ˆAØ�K‰K�O‰O˜AÕñr5cóP—|
\}}t
||«D]}||jvs
Œ
y
y)NTF)rdrœ)r2Úrangr;r¡r¢s     r3Ú__contains__z_Intervals.__contains__D
s/€Ø‰ˆ
ˆ1Ü�q˜!–ˆAØ�D—K‘KÒÙððr5N)r6r7r8Ú__doc__ržr r¥r1r5r3r™r™7
s„ñò
òór5r™có¬—eZ
dZd
Z	d<ddddddedœd	ed
eeee	e
fefdede
d
ede
deedeedeedeedeeddfd„Zede
fd„«Zd=d„Zde
defd„Zedee
fd„«Zedee
fd„«Zedee
effd„«Zedefd„«Zedeedffd„«Zdee	fd „Z d!d"œ
dee	d#e
ddfd$„Z!dee	ddfd%„Z"d&ddd'œd(ee#d)ed*ee$d+eee
efdee
eff
d,„Z%d(ee#d-ee
efdeeeffd.„Z&ddd/œd0egee#fd1ee'd2eee
ddfd3„Z(d(ee#fd4„Z)d5e#fd6„Z*d7e	d8e+d9ede,fd:„Z-	d>d7e	d8e+d9edede,f
d;„Z.y)?rzz_Pipeline component to label spans of text.

    DOCS: https://spacy.io/api/spancategorizer
    FrLrpTNrj)r~rVr|r}rmrlror€r(rnryr~rVr|r}rmrlror.cóÜ—g||
|	||d
œ|_|
|_
||_||_||_||_||_|s2|	�/|	dkDr)ttjj|	¬«
«
‚
yyy)a}Initialize the multi-label or multi-class span categorizer.

        vocab (Vocab): The shared vocabulary.
        model (thinc.api.Model): The Thinc Model powering the pipeline component.
            For multi-class classification (single label per span) we recommend
            using a Softmax classifier as a the final layer, while for multi-label
            classification (multiple possible labels per span) we recommend Logistic.
        suggester (Callable[[Iterable[Doc], Optional[Ops]], Ragged]): A function that suggests spans.
            Spans are returned as a ragged array with two integer columns, for the
            start and end positions.
        name (str): The component instance name, used to add entries to the
            losses during training.
        spans_key (str): Key of the 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
            `"spans"`.
        add_negative_label (bool): Learn to predict a special 'negative_label'
            when a Span is not annotated.
        threshold (Optional[float]): Minimum probability to consider a prediction
            positive. Defaults to 0.5. Spans with a positive prediction will be saved
            on the Doc.
        max_positive (Optional[int]): Maximum number of labels to consider
            positive per span. Defaults to None, indicating no limit.
        negative_weight (float): Multiplier for the loss terms.
            Can be used to downweight the negative samples if there are too many
            when add_negative_label is True. Otherwise its unused.
        allow_overlap (bool): If True the data is assumed to contain overlapping spans.
            Otherwise it produces non-overlapping spans greedily prioritizing
            higher assigned label scores. Only used when max_positive is 1.
        scorer (Optional[Callable]): The scoring method. Defaults to
            Scorer.score_spans for the Doc.spans[spans_key] with overlapping
            spans allowed.

        DOCS: https://spacy.io/api/spancategorizer#init
        )ÚlabelsrVrlrmr|r}Nr%)
rm)Úcfgr€rnr(ryror~Ú
ValueErrorrÚE1051Úformat)r2r€r(rnryr~rVr|r}rmrlros            r3ržzSpanCategorizer.__init__R
s„€ðf
Ø"Ø"Ø(Ø.Ø*ñ

ˆŒðˆŒ
Ø"ˆŒØˆŒ
؈Œ	؈ŒØ"4ˆÔÙ Ð!9¸lÈQÒ>NÜœVŸ\™\×0Ñ0¸lÐ0ÓKÓLÐLð?O
Ð!9ˆ}r5c
ó2—t
|jd
«
S)z¿Key of the 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.
        rV)Ústrrªr�s
 r3rŒzSpanCategorizer.key•
s€ô�4—8‘8˜KÑ(Ó)Ð)r5c
ó,—d
}
|jjd«
r|jjd«
}
no|jjd«
rT|jj	d«
jd«
r*|jj	d«
jd«
}
|
�j|
|j
k(rZ|jsMttjj|j|jjd«
¬««
‚
y
y
y
)z<Raise an error if the component can not add any more labels.NÚnOÚoutput_layer)ryr±)r(Úhas_dimÚget_dimÚhas_refÚget_refÚ	_n_labelsÚis_resizabler«rÚE922r­ry)r2r±s  r3Ú_allow_extra_labelz"SpanCategorizer._allow_extra_label�
sÞ€à
ˆØ�:‰:×јdÔ#Ø—‘×#Ñ# DÓ)‰BØ
�Z‰Z×
Ñ
 Ô
/°D·J±J×4FÑ4FØó5
ç
‰'�$‹-ð5ð—‘×#Ñ# NÓ3×;Ñ;¸DÓAˆBØ
ˆ>˜b D§N¡NÒ2Ø×$Ò$Ü Ü—K‘K×&Ñ&¨D¯I©I¸$¿*¹*×:LÑ:LÈTÓ:RÐ&ÓSóðð%ð3ˆ>r5Úlabelcó
—t
|
t«sttj«
‚
|
|j
vr
y
|j
«
|jdj|
«

|jjj|
«

y)zÎAdd a new label to the pipe.

        label (str): The label to add.
        RETURNS (int): 0 if label is already present, otherwise 1.

        DOCS: https://spacy.io/api/spancategorizer#add_label
        rr©r%)Ú
isinstancer¯r«rÚE187r©rºrªrDr€Ústringsr )r2r»s  r3Ú	add_labelzSpanCategorizer.add_label¬
sj€ô˜%¤Ô%ÜœVŸ[™[Ó)Ð)Ø�D—K‘KÑØØ×ÑÔ!Ø�‰�Ñ×!Ñ! %Ô(Ø�
‰
×Ñ×јuÔ%Ør5c
ó2—t
|jd
«
S)z†RETURNS (Tuple[str]): The labels currently added to the component.

        DOCS: https://spacy.io/api/spancategorizer#labels
        r©)Útuplerªr�s
 r3r©zSpanCategorizer.labels½
s€ô�T—X‘X˜hÑ'Ó(Ð(r5c
ó,—t
|j«
S)
z†RETURNS (List[str]): Information about the component's labels.

        DOCS: https://spacy.io/api/spancategorizer#label_data
        )rcr©r�s
 r3Ú
label_datazSpanCategorizer.label_dataÅ
s€ô�D—K‘KÓ Ð r5c
ó`—t
|j«
D�
�cic]\}
}||
“Œ
c}}
Sc
c}}
w)
z(RETURNS (Dict[str, int]): The label map.)Ú	enumerater©)r2r;r»s   r3Ú
_label_mapzSpanCategorizer._label_mapÍ
s/€ô*3°4·;±;Ô)?Ô@Ñ)?™X˜Q ��q‘Ð)?Ò@Ð@ùÓ@s™
*c
ót—|jrt|j«
d
zSt|j«
S)z RETURNS (int): Number of labels.r%)r~rBr©r�s
 r3r·zSpanCategorizer._n_labelsÒ
s0€ð×"Ò"Ü�t—{‘{Ó# aÑ'Ð'ä�t—{‘{Ó#Ð#r5c
óF—|jrt|j«
Sy
)z8RETURNS (Union[int, None]): Index of the negative label.N)r~rBrÄr�s
 r3Ú_negative_label_iz!SpanCategorizer._negative_label_iÚ
s€ð×"Ò"Ü�t—‘Ó'Ð'àr5r-có 
—|j
|
|jj¬
«}|jj	«dk(r*|jjjdd«}||fS|jj
|
|f«
}||fS)zþApply the pipeline's model to a batch of docs, without modifying them.

        docs (Iterable[Doc]): The documents to predict.
        RETURNS: The models prediction for each document.

        DOCS: https://spacy.io/api/spancategorizer#predict
        r+r)rnr(r,rMÚsumÚalloc2fÚpredict)r2r-ÚindicesÚscoress    r3rÎzSpanCategorizer.predictâ
s}€ð—.‘. ¨4¯:©:¯>©>�.Ó:ˆØ�?‰?×ÑÓ  AÒ%Ø—Z‘Z—^‘^×+Ñ+¨A¨qÓ1ˆFð˜ˆÐð—Z‘Z×'Ñ'¨¨w¨Ó8ˆFؘˆÐr5Ú
candidates)
Úcandidates_keyrÒc
ó
—|j
|
|jj¬
«}t||
«D]L\}}g|j|<|j
D])}|j|j
||d|d«

Œ+ŒNy)ao
Use the spancat suggester to add a list of span candidates to a list of docs.
        This method is intended to be used for debugging purposes.

        docs (Iterable[Doc]): The documents to modify.
        candidates_key (str): Key of the Doc.spans dict to save the candidate spans under.

        DOCS: https://spacy.io/api/spancategorizer#set_candidates
        r+rr%N)rnr(r,ÚziprLrKrD)r2r-rÒÚsuggester_outputrÑrNÚindexs       r3Úset_candidateszSpanCategorizer.set_candidatesñ
sy€ð Ÿ>™>¨$°D·J±J·N±N˜>ÓCÐä"Ð#3°TÖ:‰OˆJ˜Ø(*ˆC�I‰I�nÑ%Ø#×*Ô*�Ø—	‘	˜.Ñ)×0Ñ0°°U¸1±XÀÀaÁÐ1IÕJñ+ñ ;r5c
óÐ
—|\}}d
}t
|
«
D]Ñ\}}||j}tt|jd«}	|jddk(r?|j||||||j|z|	«|j|j<n=|j||||||j|z«|j|j<||j|z
}ŒÓy)a
Modify a batch of Doc objects, using pre-computed scores.

        docs (Iterable[Doc]): The documents to modify.
        scores: The scores to set, produced by SpanCategorizer.predict.

        DOCS: https://spacy.io/api/spancategorizer#set_annotations
        rr}rmr%N)
rÆrKr
ÚboolrªÚ_make_span_group_singlelabelrMrLrŒÚ_make_span_group_multilabel)
r2r-Úindices_scoresrÏrÐÚoffsetr;rNÚ	indices_ir}s
          r3Úset_annotationszSpanCategorizer.set_annotationssé€ð)‰ˆ�؈ܠ–o‰FˆAˆsØ 
™
×)Ñ)ˆIÜ ¤ t§x¡x°Ñ'@ÓAˆMØ�x‰x˜Ñ'¨1Ò,Ø&*×&GÑ&GØØؘ6 F¨W¯_©_¸QÑ-?Ñ$?Ð@Ø!ó	'�—	‘	˜$Ÿ(™(Ò#ð'+×&FÑ&FØØؘ6 F¨W¯_©_¸QÑ-?Ñ$?Ð@ó'�—	‘	˜$Ÿ(™(Ñ#ð

�g—o‘o aÑ(Ñ(‰Fñ!&r5rq)ÚdropÚsgdÚlossesr…ràrárâcón—|€i}|j
|jd
«
t|
d«
|j|
«

t	d„|
D««
s|S|
D�cgc]}|j
‘Œ}}|j
||jj¬«}|jj«dk(r|St|j|«
|jj||f«
\}}	|j|
||f«\}
}|	|«

|�|j|«

||jxx|
z
cc<|Sc
c}w)a1Learn from a batch of documents and gold-standard information,
        updating the pipe's model. Delegates to predict and get_loss.

        examples (Iterable[Example]): A batch of Example objects.
        drop (float): The dropout rate.
        sgd (thinc.api.Optimizer): The optimizer.
        losses (Dict[str, float]): Optional record of the loss during training.
            Updated using the component name as the key.
        RETURNS (Dict[str, float]): The updated losses dictionary.

        DOCS: https://spacy.io/api/spancategorizer#update
        rqzSpanCategorizer.updatec
3óbK
—|]'}
|
jrt|
j«
n
d–
—

Œ)y
­w
)rN)Ú	predictedrB)Ú.0Úegs  r3ú	<genexpr>z)SpanCategorizer.update.<locals>.<genexpr>8s%èø€ÐOÁhÀ¨¯ª”3�r—|‘|Ô$¸!Ó;Áhùs‚-/
r+r)r’ryr"Ú_validate_categoriesÚanyrårnr(r,rMrÌrÚbegin_updateÚget_lossÚ
finish_update)r2r…ràrárârçr-rLrÐÚbackprop_scoresÚlossÚd_scoress            r3ÚupdatezSpanCategorizer.updates
€ð(ˆ>؈FØ×ј$Ÿ)™) SÔ)ܘ(Ð$<Ô=Ø×!Ñ! (Ô+ÜÑOÁhÓOÔOàˆMÙ'/Ó0¡x �—“ xˆÐ0Ø—‘˜t¨¯©¯©�Ó8ˆØ�=‰=×ÑÓ !Ò#؈MܘŸ™ TÔ*Ø"&§*¡*×"9Ñ"9¸4À¸-Ó"Hш�ØŸ™ x°%¸°ÓA‰ˆˆhÙ˜Ô!؈?Ø×Ñ˜sÔ#؈t�y‰yÓ˜TÑ!Ó؈
ùò1sÁD2Úspans_scorescóØ—|\}}t
|jjj|j«
|jjj|j
«
«}t
j|j|j¬
«}|jr"t
j|jd«
}d}|j}t|
«
D]Ï\}	}
i}||	j}t|j
|	«
D],}
t!||
df«
}t!||
df«
}||
z|||f<Œ.|j#|
«
D]L}|j$|j&f}||vs
Π||}||j(}d|||f<|js
ŒHd|<ŒN||j
|	z
}ŒÑ|jjj+|d¬
«}|jr)t
j,«
d}d|||j.f<||z
}|jr/t1t2|j4d«}|dk7r
|xx|zcc<t3|dzj7««
}||fS)	ak
Find the loss and gradient of loss for the batch of documents and
        their predicted scores.

        examples (Iterable[Examples]): The batch of examples.
        spans_scores: Scores representing the model's predictions.
        RETURNS (Tuple[float, float]): The loss and the gradient.

        DOCS: https://spacy.io/api/spancategorizer#get_loss