+ QV-j_^RIt^RIHt^RIHt^RIHtHtHt^RI t ^RI t ^RI H t ^RI Ht^RIHt^RIHt^R IHt^R IHtHt^R IHtHt]'d^R IHt]P:!]4t]!R R44t !RR4t!!RR]4t"]!RR]44t#!RR] PH4t%!RR]4t&!RR4t'R#)N) dataclass) lru_cache) TYPE_CHECKINGAnyUnion)nn)BCELoss)initialization)PreTrainedConfig)PreTrainedModel) ModelOutputlogging)#SynthIDTextWatermarkLogitsProcessorWatermarkLogitsProcessor)WatermarkingConfigcLa]tRt^&toRtRtRtRtRtRt Rt Rt V3Rlt Rt VtR#)WatermarkDetectorOutputa Outputs of a watermark detector. Args: num_tokens_scored (np.ndarray of shape (batch_size)): Array containing the number of tokens scored for each element in the batch. num_green_tokens (np.ndarray of shape (batch_size)): Array containing the number of green tokens for each element in the batch. green_fraction (np.ndarray of shape (batch_size)): Array containing the fraction of green tokens for each element in the batch. z_score (np.ndarray of shape (batch_size)): Array containing the z-score for each element in the batch. Z-score here shows how many standard deviations away is the green token count in the input text from the expected green token count for machine-generated text. p_value (np.ndarray of shape (batch_size)): Array containing the p-value for each batch obtained from z-scores. prediction (np.ndarray of shape (batch_size)), *optional*: Array containing boolean predictions whether a text is machine-generated for each element in the batch. confidence (np.ndarray of shape (batch_size)), *optional*: Array containing confidence scores of a text being machine-generated for each element in the batch. Nc\<V^8dQh/S[PR,;R&S[PR,;R&S[PR,;R&S[PR,;R&S[PR,;R&S[PR,;R&S[PR,;R&#) Nnum_tokens_scorednum_green_tokensgreen_fractionz_scorep_value prediction confidencenpndarray)format __classdict__s"u/Volumes/fast/ai/experiments/ui-tars-smoke/.venv/lib/python3.14/site-packages/transformers/generation/watermarking.py __annotate__$WatermarkDetectorOutput.__annotate__&s0zzD(/12jj4'.34JJ%,56ZZ$ %78ZZ$ %9: T!(;< T!(=)__name__ __module__ __qualname____firstlineno____doc__rrrrrrr__annotate_func____static_attributes____classdictcell__r!s@r"rr&s8,,0*.(,N!%G!%G$(J$(J=r%rca]tRt^GtoRtRV3RlRlltV3RlRltV3RlRltV3RlR ltRR lt RV3R lR llt R t Vt R#)WatermarkDetectora Detector for detection of watermark generated text. The detector needs to be given the exact same settings that were given during text generation to replicate the watermark greenlist generation and so detect the watermark. This includes the correct device that was used during text generation, the correct watermarking arguments and the correct tokenizer vocab size. The code was based on the [original repo](https://github.com/jwkirchenbauer/lm-watermarking/tree/main). See [the paper](https://huggingface.co/papers/2306.04634) for more information. Args: model_config (`PreTrainedConfig`): The model config that will be used to get model specific arguments used when generating. device (`str`): The device which was used during watermarked text generation. watermarking_config (Union[`WatermarkingConfig`, `Dict`]): The exact same watermarking config and arguments used when generating text. ignore_repeated_ngrams (`bool`, *optional*, defaults to `False`): Whether to count every unique ngram only once or not. max_cache_size (`int`, *optional*, defaults to 128): The max size to be used for LRU caching of seeding/sampling algorithms called for every token. Examples: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM, WatermarkDetector, WatermarkingConfig >>> model_id = "openai-community/gpt2" >>> model = AutoModelForCausalLM.from_pretrained(model_id) >>> tok = AutoTokenizer.from_pretrained(model_id) >>> tok.pad_token_id = tok.eos_token_id >>> tok.padding_side = "left" >>> inputs = tok(["This is the beginning of a long story", "Alice and Bob are"], padding=True, return_tensors="pt") >>> input_len = inputs["input_ids"].shape[-1] >>> # first generate text with watermark and without >>> watermarking_config = WatermarkingConfig(bias=2.5, seeding_scheme="selfhash") >>> out_watermarked = model.generate(**inputs, watermarking_config=watermarking_config, do_sample=False, max_length=20) >>> out = model.generate(**inputs, do_sample=False, max_length=20) >>> # now we can instantiate the detector and check the generated text >>> detector = WatermarkDetector(model_config=model.config, device="cpu", watermarking_config=watermarking_config) >>> detection_out_watermarked = detector(out_watermarked, return_dict=True) >>> detection_out = detector(out, return_dict=True) >>> detection_out_watermarked.prediction array([ True, True]) >>> detection_out.prediction array([False, False]) ``` c J<V^8dQhRRRS[RS[RS[3,RS[RS[/#)r model_configr devicewatermarking_configrignore_repeated_ngramsmax_cache_size)strrdictboolint)r r!s"r"r#WatermarkDetector.__annotate__{sO``(``##7#=> ` !% `  `r%cV\V\4'gVP4pVP'g VPM VP VnVR,VnW@n\RRVPRV/VBVn \VR7!VP4Vn R#)greenlist_ratio vocab_sizer4)maxsizeNr&) isinstancer9to_dictis_encoder_decoder bos_token_iddecoder_start_token_idr>r6rr? processorr_get_ngram_score_get_ngram_score_cached)selfr3r4r5r6r7s&&&&&&r"__init__WatermarkDetector.__init__{s-t44"5"="="? .:-L-L-LL % %R^RuRu  33DE&<#1 #.. 7= AT  (1'HI^I^'_$r%c:<V^8dQhRS[PRS[/#)rprefixtarget)torch LongTensorr;)r r!s"r"r#r<s!''u'7'7''r%c@VPPV4pW#9#N)rF_get_greenlist_ids)rIrMrN greenlist_idss&&& r"rG"WatermarkDetector._get_ngram_scores99&A &&r%c4<V^8dQhRS[P/#)r input_ids)rOrP)r r!s"r"r#r<s@@%2B2B@r%c VPwr#\VPPR8H4pVPP^,V, p\ P !V4P^4\ P !W5, ^,4P^4,pVRV3,p\P!V4p\P!V4p \VP^,4Fp \P!Wz,4p /p V F.p V'dT MV RRpV R,pVPW4W&K0 VP'd9\V P!44W&\#V P%44W&K\#V P%44W&\#R\'V P%4V P%4444W&K W3#)selfhashNNNNc36"TFwrW,xK R#5irRr&).0freqoutcomes& r" =WatermarkDetector._score_ngrams_in_passage..s9)l NN)ls)shaper;rFseeding_scheme context_widthrOarange unsqueezerzerosrange collectionsCounterrHr6lenkeyssumvalueszip)rIrW batch_size seq_lengthrYnindices ngram_tensorsnum_tokens_scored_batchgreen_token_count_batch batch_idxfrequencies_tablengram_to_watermark_lookup ngram_examplerMrNs&& r"_score_ngrams_in_passage*WatermarkDetector._score_ngrams_in_passages!* t~~44 BC NN ( (1 ,x 7,,q/++A.jnq>P1Q1[1[\]1^^!!W*- "$((:"6"$((:"6}22156I + 3 3M4L M (* %!2 *2 cr8J&r*;?;W;WX^;g)8"3 ***699J9O9O9Q5R'2589R9Y9Y9[5\'2589J9Q9Q9S5T'2589),->-E-E-GIbIiIiIk)l96'27&'??r%ch<V^8dQhRS[PRS[PRS[P/#)rgreen_token_counttotal_num_tokensreturnr)r r!s"r"r#r<s4"**PRPZPZ_a_i_ir%cVPpWV,, p\P!W#,^V, ,4pWE, pV#))r>rsqrt)rIr~rexpected_countnumerdenomzs&&& r"_compute_z_score"WatermarkDetector._compute_z_scoresC--!5E$EE(9Q=OPQ Mr%c W, V, p^R^\P!V4^\P!RV^,,\P, 4, ,,,, #)r?)rsignexppi)rIxlocscalers&&&& r" _compute_pvalWatermarkDetector._compute_pvalsO W C1rwwqzQQT BEE8I1J-JKKLMMr%c j<V^8dQhRS[PRS[RS[RS[S[P ,/#)rrW z_threshold return_dictr)rOrPfloatr:rrr)r r!s"r"r#r<sB11##11 1 !2:: - 1r%c  VR,VP8Xd VR,pVPR,VPP, ^8d$\ RVPP R24hVP V4wrEVP WT4pWb8pV'd3VPV4p^V, p \VVWT, VVVV R7#V#)a Args: input_ids (`torch.LongTensor`): The watermark generated text. It is advised to remove the prompt, which can affect the detection. z_threshold (`Dict`, *optional*, defaults to `3.0`): Changing this threshold will change the sensitivity of the detector. Higher z threshold gives less sensitivity and vice versa for lower z threshold. return_dict (`bool`, *optional*, defaults to `False`): Whether to return `~generation.WatermarkDetectorOutput` or not. If not it will return boolean predictions, ma Return: [`~generation.WatermarkDetectorOutput`] or `np.ndarray`: A [`~generation.WatermarkDetectorOutput`] if `return_dict=True` otherwise a `np.ndarray`. zEMust have at least `1` token to score after the first min_prefix_len=z' tokens required by the seeding scheme.)rrrrrrr)rr)rZ:rNNra) rDrbrFrd ValueErrorr{rrr) rIrWrrrr~rrrrs &&&& r"__call__WatermarkDetector.__call__s. T?d// /!%(I ??2 !=!= = A""&..">">!??fh  04/L/LY/W,''(9M* ((1GWJ*"3!20D%% r%)rHrDr>r6rFN)F)rr)g@F) r'r(r)r*r+rJrGr{rrrr-r.r/s@r"r1r1GsL1f``.''@@<N111r%r1cLaa]tRt^toRtRV3RlV3RllltRtRtVtV;t #)BayesianDetectorConfiga2 This is the configuration class to store the configuration of a [`BayesianDetectorModel`]. It is used to instantiate a Bayesian Detector model according to the specified arguments. Configuration objects inherit from [`PreTrainedConfig`] and can be used to control the model outputs. Read the documentation from [`PreTrainedConfig`] for more information. Args: watermarking_depth (`int`, *optional*): The number of tournament layers. base_rate (`float1`, *optional*, defaults to 0.5): Prior probability P(w) that a text is watermarked. c4<V^8dQhRS[R,RS[/#)rwatermarking_depthN base_rate)r;r)r r!s"r"r##BayesianDetectorConfig.__annotate__s##3:##r%c \<WnW nRVnRVn\SV`!R/VBR#)Nr&)rr model_namer5superrJ)rIrrkwargs __class__s&&&,r"rJBayesianDetectorConfig.__init__s-"4"#'  "6"r%cWnW nR#rR)rr5)rIrr5s&&&r"set_detector_information/BayesianDetectorConfig.set_detector_information s $#6 r%)rrr5r)Nr) r'r(r)r*r+rJrr-r. __classcell__rr!s@@r"rrs ##77r%rc8a]tRtRtoRtRtRtV3RltRtVt R#)$BayesianWatermarkDetectorModelOutputia@ Base class for outputs of models predicting if the text is watermarked. Args: loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `labels` is provided): Language modeling loss. posterior_probabilities (`torch.FloatTensor` of shape `(1,)`): Multiple choice classification loss. Ncv<V^8dQh/S[PR,;R&S[PR,;R&#)rNlossposterior_probabilities)rO FloatTensor)r r!s"r"r#1BayesianWatermarkDetectorModelOutput.__annotate__s5   d ")#..5<r%r&) r'r(r)r*r+rrr,r-r.r/s@r"rrs&*D8<r%rcfaa]tRtRtoRtV3RlV3RlltV3RlRltV3RlRltR tVt V;t #) %BayesianDetectorWatermarkedLikelihoodi zvWatermarked likelihood model for binary-valued g-values. This takes in g-values and returns p(g_values|watermarked). c <V^8dQhRS[/#)rr)r;)r r!s"r"r#2BayesianDetectorWatermarkedLikelihood.__annotate__&spp3pr%c  X<\SV`4Wn\PP RR\P !^^V4,,4Vn\PP R\P !^^VPV4,4VnR#)z!Initializes the model parameters.gMbP?Ng) rrJrrOr Parameterrandnbetadelta)rIrrs&&r"rJ.BayesianDetectorWatermarkedLikelihood.__init__&ss "4HH&&teekk!QHZ6[.['[\ XX'' Aq$BYBY[m0n(no r%cx<V^8dQhRS[PRS[S[PS[P3,/#rg_valuesr)rOTensortuple)r r!s"r"r#r-s1777% ell@Z:[7r%c \P!\P!VRR7VPRR7p\P!VRR7pVP R,VP VP P4R,,P4VP,p\P!V4p^V, pWT3#)aComputes the unique token probability distribution given g-values. Args: g_values (`torch.Tensor` of shape `(batch_size, seq_len, watermarking_depth)`): PRF values. Returns: p_one_unique_token and p_two_unique_tokens, both of shape [batch_size, seq_len, watermarking_depth]. p_one_unique_token[i,t,l] gives the probability of there being one unique token in a tournament match on layer l, on timestep t, for batch item i. p_one_unique_token[i,t,l] + p_two_unique_token[i,t,l] = 1. dim)axis)diagonalrra).NrZ).N) rOrepeat_interleaverfrtrilrtypedtypesqueezersigmoid)rIrrlogitsp_two_unique_tokensp_one_unique_tokens&& r"_compute_latents6BayesianDetectorWatermarkedLikelihood._compute_latents-s&  # #EOOH"$EtG^G^eg h JJq2 &**\*QVVDJJ4D4D-Ei-PPYY[^b^g^gg#mmF3!44!66r%cN<V^8dQhRS[PRS[P/#rrOr)r r!s"r"r#rMs'SS SSr%c dVPV4wr#RVR,V,V,,#)aComputes the likelihoods P(g_values|watermarked). Args: g_values (`torch.Tensor` of shape `(batch_size, seq_len, watermarking_depth)`): g-values (values 0 or 1) Returns: p(g_values|watermarked) of shape [batch_size, seq_len, watermarking_depth]. r)r)rIrrrs&& r"forward-BayesianDetectorWatermarkedLikelihood.forwardMs5372G2G2Q/x#~)<)minmaxgKH9infzi...->irawJ?)rOrfclamplogreinsumr) rIrrrrlog_likelihoods_watermarkedlog_likelihoods_unwatermarkedlog_oddsrelative_surprisal_likelihoodrelative_surprisal_priorrelative_surprisals &&&&& r"_compute_posterior(BayesianDetectorModel._compute_posteriors.t, Et:&+ii W]bhmnsht2u(v%.N). Y(P%$)99U#3eiiE 6J#J 6U}}/00r%c|<V^8dQhRS[PRS[PRS[PR,RS[/#)rrrlabelsNr)rOrr)r r!s"r"r#rsJ)\)\,,)\ll)\ t# )\ .)\r%c VPV4pR\P!V4,pVPVVVVPR7pRp Vej\ 4p \P !VPP^,4p W,p V !\P!VRR4V4V ,p V'g V fV3#W3#\WR7#)a Computes the watermarked posterior P(watermarked|g_values). Args: g_values (`torch.Tensor` of shape `(batch_size, seq_len, watermarking_depth, ...)`): g-values (with values 0 or 1) mask: A binary array shape [batch_size, seq_len] indicating which g-values should be used. g-values with mask value 0 are discarded. Returns: p(watermarked | g_values), of shape [batch_size]. r)rrrrNr)rrr) rrO ones_likerrr rmrrr) rIrrrloss_batch_weightrrroutrloss_fctloss_unwweight loss_weights &&&&&& r"rBayesianDetectorModel.forwards,#'"C"CH"M$'%//(*C$C!%%$;&?** &   yH"YYt'H'H'N'NPQ'QRN(>> from transformers import ( ... AutoTokenizer, BayesianDetectorModel, SynthIDTextWatermarkLogitsProcessor, SynthIDTextWatermarkDetector ... ) >>> # Load the detector. See https://github.com/huggingface/transformers-research-projects/tree/main/synthid_text for training a detector. >>> detector_model = BayesianDetectorModel.from_pretrained("joaogante/dummy_synthid_detector") >>> logits_processor = SynthIDTextWatermarkLogitsProcessor( ... **detector_model.config.watermarking_config, device="cpu" ... ) >>> tokenizer = AutoTokenizer.from_pretrained(detector_model.config.model_name) >>> detector = SynthIDTextWatermarkDetector(detector_model, logits_processor, tokenizer) >>> # Test whether a certain string is watermarked >>> test_input = tokenizer(["This is a test input"], return_tensors="pt") >>> is_watermarked = detector(test_input.input_ids) ``` c,<V^8dQhRS[RS[RS[/#)rdetector_modulelogits_processor tokenizer)rrr)r r!s"r"r#)SynthIDTextWatermarkDetector.__annotate__s)##.#># #r%c*WnW nW0nR#rRrrr)rIrrrs&&&&r"rJ%SynthIDTextWatermarkDetector.__init__s / 0"r%c4<V^8dQhRS[P/#)rtokenized_outputsr)r r!s"r"r#rs==%,,=r%cRVPPVVPPR7RVPP^, R13,pVPP VR7pW2,pVPP VR7pVPWT4#))rW eos_token_idrZN)rW)rcompute_eos_token_maskrr ngram_lencompute_context_repetition_maskcompute_g_valuesr)rIreos_token_maskcontext_repetition_mask combined_maskrs&& r"r%SynthIDTextWatermarkDetector.__call__s..EE'44F  T " " , ,q 0 2 24 #'"7"7"W"W'#X#  0@ ((99': ##H<r2s!,, %2,(Y7   H % )) )@iiX7-7:  =; =  =;SBII;S|@\O@\FC=C=r%