d ddlZddlZddlZddlZddlZddlZddlZddlZddlZddl m Z m Z ddlm Z ddl mZddlmZmZddlmZmZmZmZmZmZmZddlmZdd lmZdd lmZdd l m!Z!dd l"m#Z#dd l$m%Z%ddl&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,eedddfZ-e*r ddl.Z/ddl0m1Z1e+rddl2Z2ddl3m4Z4m5Z5ddl6m7Z7ddl8m9Z9ndZ5dZ9er ddl:m;Z;ddle?Z@dZAdZBdZC d>de#deeeDeeEfdeeDdeeDfd ZF d>deeeDeeEfdeeDdeeDfd!ZGd?d"eeDfd#ZHd$edeeDd%eed&eeDeeDeDfffd'ZIGd(d)eJZKGd*d+e ZLGd,d-ZMGd.d/eMZNGd0d1eMZOGd2d3eMZPGd4d5e ZQd6ZRe+r dd7lSmTZTmUZUmVZVmWZWe(eRGd8d9eQZXGd:d;eXZYGd<d=ZZdS)@N)ABCabstractmethod)UserDict)contextmanager)abspathexists) TYPE_CHECKINGAnyDictListOptionalTupleUnion)custom_object_save)PreTrainedFeatureExtractor)BaseImageProcessor) ModelCard) AutoConfig)PreTrainedTokenizer) ModelOutputadd_end_docstringsinfer_frameworkis_tf_availableis_torch_availablelogging GenericTensorz torch.Tensorz tf.Tensor) TFAutoModel) DataLoaderDataset) AutoModel) KeyDataset)TFPreTrainedModel)PreTrainedModelcVt|dkrtd|dS)Nr"z5This collate_fn is meant to be used with batch_size=1r)len ValueError)itemss ;lib/python3.11/site-packages/transformers/pipelines/base.py no_collate_fnr+Bs) 5zzQPQQQ 8Oc t|}t|dtjr:|dj}t|}dvr"tjfd|DdS|dkr(dkr"tjfd|DdSt fd|D}tfd |D}|dj} |d krD||kr"tjfd |DdStj ||f| |z} nX|d kr#tj |||df| |z} n/|dkr)tj |||d|df| |z} t|D]\} } |d kr|dkrB| d | | t| d df<T| d | | dt| df<|d kr|dkrE| d | | t| d dddf<| d | | dt| dddf<+|dkr|dkrI| d | | t| d dddddf<| d | | dt| dddddf<| Sfd|DS)Nr) pixel_valuesimagec g|] }| Sr1.0itemkeys r* z_pad..Q:::Dd3i:::r,)diminput_featuresc g|] }| Sr1r1r2s r*r6z_pad..Tr7r,c3>K|]}|jdVdSr"Nshaper2s r* z_pad..U.>>c+>>>>>>r,c3>K|]}|jdVdSr=r>r2s r*r@z_pad..VrAr,rc g|] }| Sr1r1r2s r*r6z_pad..]s!>!>!>$s)!>!>!>r,)dtypeleftc g|] }| Sr1r1r2s r*r6z_pad..ws,,,dS ,,,r,) r' isinstancetorchTensorr?catmaxminrDzeros enumerateclone) r)r5 padding_value padding_side batch_sizer?r8 max_length min_lengthrDtensorir4s ` r*_padrZHsUJ%(3-..--a #%jj + + +9::::E:::BBB B AXX#!1119::::E:::BBB B>>>>>>>>> >>>>>>>>> a # !88Z''y!>!>!>!>!>!>!>AFFFF[*j!9GGG-WFF AXX[*j%)!DERRRUbbFF AXX[*j%)U2Y!OW\]]]`mmF '' P PGAtaxx6))6:3il6H6H6J6JF1s49Q<0002223359#Yq\5G5G5I5IF11DIaL 1 111226))9=c19K9K9M9MF1s49Q<00022AAA5668 input_ids> input_valuesr.r:>p_maskspecial_tokens_maskr">attention_masktoken_type_ids)setkeysr(rZ) r)rgr4paddedr5_padding_valuef_padding_valuefeature_extractorrTt_padding_value tokenizers r*innerzpad_collate_fn..inners158==??##  D499;;4''  \_`d`i`i`k`k\l\l     (  I ICm##$):)F%4NN%4NNJJJ!0999!"<<<HHF3KK r,)r( pad_token_idrTgetattr)rmrkt_padding_sidef_padding_sidernrjrTrls`` @@@r*pad_collate_fnrszsNN.6]^^^  ! )M  (4O&3N$!"3_dKK !2NDII!n&@^WeEeEe tP^ t tdr t t   L!% !% : Lr,config model_classestask frameworkc tststdt|tr(||d<d}to|dv}to|dv}|rB|r||dt fz}|r||dtfz}|jrg} |jD]m} tj d} |r(t| | d } | | | |r+t| d | d } | | | n|t| z}t|d krtd ||D]} |}|dkr5|d r d|d<t$dn:|dkr4|drd|d<t$d | j|fi|}t+|dr|}n#t.tf$rYwxYwt|trtd|d|d|t1|j}||fS)a Select framework (TensorFlow or PyTorch) to use from the `model` passed. Returns a tuple (framework, model). If `model` is instantiated, this function will just infer the framework from the model class. Otherwise `model` is actually a checkpoint name and this method will try to instantiate it using `model_classes`. Since we don't want to instantiate the model twice, this model is returned for use by the pipeline. If both frameworks are installed and available for `model`, PyTorch is selected. Args: model (`str`, [`PreTrainedModel`] or [`TFPreTrainedModel`]): The model to infer the framework from. If `str`, a checkpoint name. The model to infer the framewrok from. config ([`AutoConfig`]): The config associated with the model to help using the correct class model_classes (dictionary `str` to `type`, *optional*): A mapping framework to class. task (`str`): The task defining which pipeline will be returned. model_kwargs: Additional dictionary of keyword arguments passed along to the model's `from_pretrained(..., **model_kwargs)` function. Returns: `Tuple`: A tuple framework, model. At least one of TensorFlow 2.0 or PyTorch should be installed. To install TensorFlow 2.0, read the instructions at https://www.tensorflow.org/install/ To install PyTorch, read the instructions at https://pytorch.org/._from_pipeliner1>Npt>Ntfr{r| transformersNTFrz2Pipeline cannot infer suitable model classes from z.h5Tfrom_tfz}Model might be a TensorFlow model (ending with `.h5`) but TensorFlow is not available. Trying to load the model with PyTorch.z.binfrom_ptz{Model might be a PyTorch model (ending with `.bin`) but PyTorch is not available. Trying to load the model with Tensorflow.evalzCould not load model z$ with any of the following classes: .)rr RuntimeErrorrJstrgetr!r architectures importlib import_modulerpappendtupler'r(copyendswithloggerwarningfrom_pretrainedhasattrrOSErrorr __class__)modelrtrurvrw model_kwargs class_tuplelook_ptlook_tfclasses architecturetransformers_module_class model_classkwargss r*infer_framework_load_modelrs!B    %7%9%9  Q   %4p)- %& $&&D9 +D!##A \(A  T R)M,=,=dYL,Q,QQ  T)M,=,=d[N,S,SS   7G & 4 / / &/&=n&M&M#/$%8,MMF)v.../$%8:M|:M:MtTTF)v...%g6K {  q YRWYYZZ Z&  K!&&((FD  U^^E%:%: $(y!=d""u~~f'='="$(y!@  3 3EDDVDD5&)))!JJLLEZ(     eS ! ! pnUnn`knnnoo o#EO44 e s42H((H<;H<c t|trtj|fd|i|}n|j}t ||f||||d|S)ar Select framework (TensorFlow or PyTorch) to use from the `model` passed. Returns a tuple (framework, model). If `model` is instantiated, this function will just infer the framework from the model class. Otherwise `model` is actually a checkpoint name and this method will try to instantiate it using `model_classes`. Since we don't want to instantiate the model twice, this model is returned for use by the pipeline. If both frameworks are installed and available for `model`, PyTorch is selected. Args: model (`str`, [`PreTrainedModel`] or [`TFPreTrainedModel`]): The model to infer the framework from. If `str`, a checkpoint name. The model to infer the framewrok from. model_classes (dictionary `str` to `type`, *optional*): A mapping framework to class. task (`str`): The task defining which pipeline will be returned. model_kwargs: Additional dictionary of keyword arguments passed along to the model's `from_pretrained(..., **model_kwargs)` function. Returns: `Tuple`: A tuple framework, model. rz)rurzrvrw)rJrrrrtr)rrurvrwrrts r*infer_framework_from_modelrso<%+EWW$W,WW % v %24d^g  kw  r,revisionc*tjdttst st dt |trt r%tstj ||}nqtr%t stj ||}n> tj ||}n&#t$rtj ||}YnwxYwt|j }|S)a[ Select framework (TensorFlow or PyTorch) to use. Args: model (`str`, [`PreTrainedModel`] or [`TFPreTrainedModel`]): If both frameworks are installed, picks the one corresponding to the model passed (either a model class or the model name). If no specific model is provided, defaults to using PyTorch. zb`get_framework` is deprecated and will be removed in v5, use `infer_framework_from_model` instead.ry)r)warningswarn FutureWarningrrrrJrr!rrrrr)rrrws r* get_frameworkrBs> Ml    %7%9%9  Q   % N    N(9(9 N-ehGGGEE    N'9';'; N/IIIEE N!1%(KKK N N N#3EHMMM N 00I sC C<;C< targeted_task task_optionsreturnc6trtsd}ntrtsd}|d}|r%||vrtd|||d}n"d|vr|dd}ntd|d}||S)a Select a default model to use for a given task. Defaults to pytorch if ambiguous. Args: targeted_task (`Dict` ): Dictionary representing the given task, that should contain default models framework (`str`, None) "pt", "tf" or None, representing a specific framework if it was specified, or None if we don't know yet. task_options (`Any`, None) Any further value required by the task to get fully specified, for instance (SRC, TGT) languages for translation task. Returns `str` The model string representing the default model for this pipeline r{r|defaultz9The task does not provide any default models for options rzXThe task defaults can't be correctly selected. You probably meant "translation_XX_to_YY")rrr()rrwrdefaultsdefault_modelss r*get_default_model_and_revisionrds*O$5$5   #5#7#7 Y'H v x ' 'gYegghh h!,/8 H  &y1':tuuu ) $$r,c0eZdZdZdededeffd ZxZS)PipelineExceptionz Raised by a [`Pipeline`] when handling __call__. Args: task (`str`): The task of the pipeline. model (`str`): The model used by the pipeline. reason (`str`): The error message to display. rvrreasoncft|||_||_dSN)super__init__rvr)selfrvrrrs r*rzPipelineException.__init__s-      r,)__name__ __module__ __qualname____doc__rr __classcell__rs@r*rrs\Scr,rc(eZdZdZedZdS)ArgumentHandlerzQ Base interface for handling arguments for each [`~pipelines.Pipeline`]. ctrNotImplementedError)rargsrs r*__call__zArgumentHandler.__call__!###r,N)rrrrrrr1r,r*rrs9$$^$$$r,rc (eZdZdZgdZ ddeedeedeedefdZe d Z e d e e e e ffd Zd e e e e fd efd Ze ddedeedeedeed df dZdS)PipelineDataFormata Base class for all the pipeline supported data format both for reading and writing. Supported data formats currently includes: - JSON - CSV - stdin/stdout (pipe) `PipelineDataFormat` also includes some utilities to work with multi-columns like mapping from datasets columns to pipelines keyword arguments through the `dataset_kwarg_1=dataset_column_1` format. Args: output_path (`str`, *optional*): Where to save the outgoing data. input_path (`str`, *optional*): Where to look for the input data. column (`str`, *optional*): The column to read. overwrite (`bool`, *optional*, defaults to `False`): Whether or not to overwrite the `output_path`. )jsoncsvpipeF output_path input_pathcolumn overwritec||_||_||dndg|_t |jdk|_|jrd|jD|_|:|s8t t|jrt|jd|8t t|jst|jddSdS)N,r"cbg|],}d|vr"t|dn||f-S)=)rsplitr3cs r*r6z/PipelineDataFormat.__init__..s;\\\1#((5...A\\\r,z already exists on diskz doesnt exist on disk) rrrrr'is_multi_columnsrrr)rrrrrs r*rzPipelineDataFormat.__init__s'$+1+=fll3'''B4 #DK 0 01 4   ]\\PTP[\\\DK  "9 "gd.//00 L!1JJJKKK  !'$/2233 IGGGHHH " ! I Ir,ctrrrs r*__iter__zPipelineDataFormat.__iter__rr,datact)z Save the provided data object with the representation for the current [`~pipelines.PipelineDataFormat`]. Args: data (`dict` or list of `dict`): The data to store. rrrs r*savezPipelineDataFormat.saves"###r,rctj|j\}}tjj|df}t |d5}tj||dddn #1swxYwY|S)z Save the provided data object as a pickle-formatted binary data on the disk. Args: data (`dict` or list of `dict`): The data to store. Returns: `str`: Path where the data has been saved. picklezwb+N) ospathsplitextrextsepjoinopenrdump)rrr_ binary_pathf_outputs r* save_binaryzPipelineDataFormat.save_binarys'""4#344agn))4*:;; +u % % ( Kh ' ' ' ( ( ( ( ( ( ( ( ( ( ( ( ( ( (sBBBformatc|dkrt||||S|dkrt||||S|dkrt||||Std|d)a Creates an instance of the right subclass of [`~pipelines.PipelineDataFormat`] depending on `format`. Args: format (`str`): The format of the desired pipeline. Acceptable values are `"json"`, `"csv"` or `"pipe"`. output_path (`str`, *optional*): Where to save the outgoing data. input_path (`str`, *optional*): Where to look for the input data. column (`str`, *optional*): The column to read. overwrite (`bool`, *optional*, defaults to `False`): Whether or not to overwrite the `output_path`. Returns: [`~pipelines.PipelineDataFormat`]: The proper data format. rrrrzUnknown reader z% (Available reader are json/csv/pipe))JsonPipelineDataFormatCsvPipelineDataFormatPipedPipelineDataFormatKeyError)rrrrrs r*from_strzPipelineDataFormat.from_strs4 V  )+z6U^___ _ u__(j&T]^^^ ^ v  *; FV_``` `ZVZZZ[[ [r,NF)rrrrSUPPORTED_FORMATSr rboolrrrrdictr rr staticmethodrr1r,r*rrsu&0// IIc]ISMI I  IIII.$$^$$tT$Z/0$$$^$dDJ&6 7C$  \ \ \c] \SM \ \  \ \ \\ \ \ \r,rcveZdZdZ d deedeedeeffd ZdZdee fd Z xZ S) ra Support for pipelines using CSV data format. Args: output_path (`str`, *optional*): Where to save the outgoing data. input_path (`str`, *optional*): Where to look for the input data. column (`str`, *optional*): The column to read. overwrite (`bool`, *optional*, defaults to `False`): Whether or not to overwrite the `output_path`. FrrrcRt||||dS)Nr)rr)rrrrrrs r*rzCsvPipelineDataFormat.__init__(s, j&INNNNNr,c#Kt|jd5}tj|}|D]4|jrfd|jDV|jdV5 ddddS#1swxYwYdS)Nrc(i|]\}}||Sr1r1)r3krrows r* z2CsvPipelineDataFormat.__iter__..6s#===A1c!f===r,r)rrr DictReaderrr)rfreaderrs @r*rzCsvPipelineDataFormat.__iter__1s $/3 ' ' .1^A&&F . .(.===========dk!n-----  . . . . . . . . . . . . . . . . . . .sA A33A7:A7rcNt|jd5}t|dkrctj|t |d}|||ddddS#1swxYwYdS)z Save the provided data object with the representation for the current [`~pipelines.PipelineDataFormat`]. Args: data (`List[dict]`): The data to store. wrN) rrr'r DictWriterlistrg writeheader writerows)rrrwriters r*rzCsvPipelineDataFormat.save:s$"C ( ( 'A4yy1}}4Q +?+?@@""$$$  &&&  ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' 'sA7BB!Br) rrrrr rrrr rrrrs@r*rrs    OOc]OSMO OOOOOO... 'd ' ' ' ' ' ' ' 'r,rcjeZdZdZ d deedeedeeffd ZdZdefd Z xZ S) ra Support for pipelines using JSON file format. Args: output_path (`str`, *optional*): Where to save the outgoing data. input_path (`str`, *optional*): Where to look for the input data. column (`str`, *optional*): The column to read. overwrite (`bool`, *optional*, defaults to `False`): Whether or not to overwrite the `output_path`. Frrrct||||t|d5}tj||_ddddS#1swxYwYdS)Nrr)rrrrload_entries)rrrrrrrs r*rzJsonPipelineDataFormat.__init__Ts j&INNN *c " " )a IaLLDM ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) )sAA"%A"c#K|jD]4|jrfd|jDV|jdV5dS)Nc(i|]\}}||Sr1r1)r3rrentrys r*rz3JsonPipelineDataFormat.__iter__..cs#;;;tq!q%(;;;r,r)r rr)rrs @r*rzJsonPipelineDataFormat.__iter__`sl] , ,E$ ,;;;;t{;;;;;;;DKN+++++  , ,r,rct|jd5}tj||ddddS#1swxYwYdS)z| Save the provided data object in a json file. Args: data (`dict`): The data to store. rN)rrrr)rrrs r*rzJsonPipelineDataFormat.savegs$"C ( ( A IdA                     s 9==r) rrrrr rrrrrrrs@r*rrHs    ) )c] )SM ) ) ) ) ) ) ),,,r,rcZeZdZdZdZdefdZdeeeefde ffd Z xZ S)ra Read data from piped input to the python process. For multi columns data, columns should separated by If columns are provided, then the output will be a dictionary with {column_x: value_x} Args: output_path (`str`, *optional*): Where to save the outgoing data. input_path (`str`, *optional*): Where to look for the input data. column (`str`, *optional*): The column to read. overwrite (`bool`, *optional*, defaults to `False`): Whether or not to overwrite the `output_path`. c#KtjD]Z}d|vrP|d}|jr"dt |j|DVDt |VV|V[dS)N c i|] \\}}}|| Sr1r1)r3rrls r*rz4PipedPipelineDataFormat.__iter__..s"RRR&!a61RRRr,)sysstdinrrzipr)rlines r*rz PipedPipelineDataFormat.__iter__sI  Dt||zz$'';&RR3t{D;Q;QRRRRRRR++%%%%   r,rc$t|dS)z^ Print the data. Args: data (`dict`): The data to store. N)printrs r*rzPipedPipelineDataFormat.saves d r,rcr|jtdt|S)NzWhen using piped input on pipeline outputting large object requires an output file path. Please provide such output path through --output argument.)rrrr)rrrs r*rz#PipedPipelineDataFormat.save_binarys>   #M  ww""4(((r,) rrrrrrrrr rrrrs@r*rrrs     )dDJ&6 7)C))))))))))r,rc>eZdZdZedZedZdS) _ScikitCompatzA Interface layer for the Scikit and Keras compatibility. ctrrrXs r* transformz_ScikitCompat.transformrr,ctrrr!s r*predictz_ScikitCompat.predictrr,N)rrrrrr#r%r1r,r*rrsT$$^$$$^$$$r,ra Arguments: model ([`PreTrainedModel`] or [`TFPreTrainedModel`]): The model that will be used by the pipeline to make predictions. This needs to be a model inheriting from [`PreTrainedModel`] for PyTorch and [`TFPreTrainedModel`] for TensorFlow. tokenizer ([`PreTrainedTokenizer`]): The tokenizer that will be used by the pipeline to encode data for the model. This object inherits from [`PreTrainedTokenizer`]. modelcard (`str` or [`ModelCard`], *optional*): Model card attributed to the model for this pipeline. framework (`str`, *optional*): The framework to use, either `"pt"` for PyTorch or `"tf"` for TensorFlow. The specified framework must be installed. If no framework is specified, will default to the one currently installed. If no framework is specified and both frameworks are installed, will default to the framework of the `model`, or to PyTorch if no model is provided. task (`str`, defaults to `""`): A task-identifier for the pipeline. num_workers (`int`, *optional*, defaults to 8): When the pipeline will use *DataLoader* (when passing a dataset, on GPU for a Pytorch model), the number of workers to be used. batch_size (`int`, *optional*, defaults to 1): When the pipeline will use *DataLoader* (when passing a dataset, on GPU for a Pytorch model), the size of the batch to use, for inference this is not always beneficial, please read [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([`~pipelines.ArgumentHandler`], *optional*): Reference to the object in charge of parsing supplied pipeline parameters. device (`int`, *optional*, defaults to -1): Device ordinal for CPU/GPU supports. Setting this to -1 will leverage CPU, a positive will run the model on the associated CUDA device id. You can pass native `torch.device` or a `str` too. binary_output (`bool`, *optional*, defaults to `False`): Flag indicating if the output the pipeline should happen in a binary format (i.e., pickle) or as raw text. )PipelineChunkIteratorPipelineDatasetPipelineIteratorPipelinePackIteratorceZdZdZdZ d3deddeedeed ee d ee d ee d e d e dee dfdeee dfdefdZd4de defdZdZdZedZdZdZdeee effdZedZeded ed!ee effd"Zed#ee efd$ed!e fd%Z!ed&e d'ed!efd(Z"d)Z#d*Z$d+e d,e fd-Z%ddd.d/Z&d0Z'd1Z(d2Z)dS)5Pipelinea The Pipeline class is the class from which all pipelines inherit. Refer to this class for methods shared across different pipelines. Base class implementing pipelined operations. Pipeline workflow is defined as a sequence of the following operations: Input -> Tokenization -> Model Inference -> Post-Processing (task dependent) -> Output Pipeline supports running on CPU or GPU through the device argument (see below). Some pipeline, like for instance [`FeatureExtractionPipeline`] (`'feature-extraction'`) output large tensor object as nested-lists. In order to avoid dumping such large structure as textual data we provide the `binary_output` constructor argument. If set to `True`, the output will be stored in the pickle format. NrFr)r%r$rmrkimage_processor modelcardrwrv args_parserdevicez torch.device torch_dtypez torch.dtype binary_outputc  |t||j\}}||_||_||_||_||_||_||_t|jdd} | | td|jdkr7| 5t| tr| dks|j | | 3| /tt| } nd} t#r|jdkrt| t$jr| |_nwt| t(rt%j| |_nH| dkrt%jd|_n(t%jd| |_n | | nd|_| |_| |_|jjj}|y||vru|jj|||jr*|jjjd i||d|_| d d|_| d d|_|j d i| \|_!|_"|_#|j/|j*t|jtHr|j|_dSdSdSdS) N)rt hf_device_mapzThe model has been loaded with `accelerate` and therefore cannot be moved to a specific device. Please discard the `device` argument when creating your pipeline object.r{rrFcpuzcuda:rU num_workersr1)%rrtrvrrmrkr,r-rwrpr(rJinttonextitervaluesrrKr/rr0r1task_specific_paramsupdater can_generategeneration_config call_countpop _batch_size _num_workers_sanitize_parameters_preprocess_params_forward_params_postprocess_paramsr)rrrmrkr,r-rwrvr.r/r0r1rr3r;s r*rzPipeline.__init__s  9% UUU Iu  "!2.""  OTBB  $);T  >T ! !f&8*VUXBYBY&8^dgh^h^h JMM& ! ! ! >(d=#7#7#9#9::;;    ?DNd$:$:&%,// =$ FC(( =#l622 !#l511 #l+;6+;+;<< $*$6&&BDK&* $z0E  +8L0L0L J  $ $%9%=%=d%C%C D D Dz&&(( V3 ,3UU6J6N6Nt6T6TUUU!::lD99"JJ}d;;RkRVRkRuRuntRuRuO!5t7O   'D,B,N$02DEE >(,'=$$$ ( ',N,N > >r,save_directorysafe_serializationctj|r td|ddStj|dt |dr|j}i}| D]\}}|d|j kr|}|dj }| dd }|d|dj |d<td |d D|d <td |d D|d <|||<||jj_t%|||j|||j|j||j|j||j|j|dSdS)ad Save the pipeline's model and tokenizer. Args: save_directory (`str`): A path to the directory where to saved. It will be created if it doesn't exist. safe_serialization (`str`): Whether to save the model using `safetensors` or the traditional way for PyTorch or Tensorflow zProvided path (z#) should be a directory, not a fileNT)exist_ok_registered_implimplrrFc3$K|] }|jV dSrrrs r*r@z+Pipeline.save_pretrained..[$"B"B!1:"B"B"B"B"B"Br,r{c3$K|] }|jV dSrrNrs r*r@z+Pipeline.save_pretrained..\rOr,r|)rH)rrisfilererrormakedirsrrKrr)rrrrrrrtcustom_pipelinesrsave_pretrainedrmrkr-) rrGrH pipeline_inforTrvinfo module_name last_modules r*rUzPipeline.save_pretrained?s 7>>. ) )  LL^>^^^ _ _ _ F NT2222 4+ , , 5 16688M! +1133 . . d<4>11yy{{"6l5 )//44R8 "-GGV 0EGGV ""B"BtDz"B"B"BBBT ""B"BtDz"B"B"BBBT )- &&1ADJ  . t^ 4 4 4 "">FX"YYY > % N * *> : : :  ! -  " 2 2> B B B > % N * *> : : : : : & %r,c||Szn Scikit / Keras interface to transformers' pipelines. This method will forward to __call__(). r1r!s r*r#zPipeline.transformntAwwr,c||Sr[r1r!s r*r%zPipeline.predicttr\r,c#^K|jdkrHtj|jdkrdn d|j5dVddddS#1swxYwYdS|jjdkrCtj|j5dVddddS#1swxYwYdSdVdS)a Context Manager allowing tensor allocation on the user-specified device in framework agnostic way. Returns: Context manager Examples: ```python # Explicitly ask for tensor allocation on CUDA device :0 pipe = pipeline(..., device=0) with pipe.device_placement(): # Every framework specific tensor allocation will be done on the request device output = pipe(...) ```r|rFz/CPU:0z /device:GPU:Ncuda)rwr|r/typerKr_rs r*device_placementzPipeline.device_placementzsS" >T ! !t{b'8'888>ZT[>Z>Z[[                    {6))Z&&t{33EEEs#A  A A  BB #B c 8|||jS)av Ensure PyTorch tensors are on the specified device. Args: inputs (keyword arguments that should be `torch.Tensor`, the rest is ignored): The tensors to place on `self.device`. Recursive on lists **only**. Return: `Dict[str, torch.Tensor]`: The same as `inputs` but on the proper device. )_ensure_tensor_on_devicer/)rinputss r*ensure_tensor_on_devicez Pipeline.ensure_tensor_on_devices,,VT[AAAr,c t|tr.tfd|DSt|tr!fd|DSt|tr.t fd|DSt|t rfd|DSt|t rt fd|DSt|tjr`tj dkr3|j tj tj hvr| }|S|S)NcDi|]\}}||Sr1rcr3namerXr/rs r*rz5Pipeline._ensure_tensor_on_device..s/hhhvt44VVDDhhhr,cDi|]\}}||Sr1rhris r*rz5Pipeline._ensure_tensor_on_device..s0kkkLDRXD$77GGkkkr,cDi|]\}}||Sr1rhris r*rz5Pipeline._ensure_tensor_on_device..s2tttUaUY[aT4#@#@#P#Ptttr,c<g|]}|Sr1rhr3r4r/rs r*r6z5Pipeline._ensure_tensor_on_device..s)SSSDD11$??SSSr,c<g|]}|Sr1rhrns r*r6z5Pipeline._ensure_tensor_on_device..s)YYY$$77fEEYYYr,r4)rJrr)rrrrrKrLr/rDfloat16bfloat16floatr7)rrdr/s` `r*rcz!Pipeline._ensure_tensor_on_devices fk * * hhhhhY_YeYeYgYghhh  % % kkkkk\b\h\h\j\jkkk k  ) ) tttttekeqeqesestttuu u  % % SSSSSFSSS S  & & YYYYYRXYYYZZ Z  - - e,,,,%-QVQ_A`1`1`99V$$ $Mr,supported_modelsc t|tsg}|D]R\}}t|tr#|t|=||St |drs|jjD]T\}}t|tr |d|D:||j U|}|j j j |vr:t d|j j j d|jd|ddSdS)z Check if the model class is in supported by the pipeline. Args: supported_models (`List[str]` or `dict`): The list of models supported by the pipeline, or a dictionary with model class values. _model_mappingcg|] }|j Sr1rN)r3ms r*r6z-Pipeline.check_model_type..s6Q6Q6Qaqz6Q6Q6Qr,z The model 'z' is not supported for z. Supported models are rN)rJrr)rextendrrru_extra_contentrrrrrRrv)rrssupported_models_namesr model_namers r*check_model_typezPipeline.check_model_types*D11 6%' "!1!7!7!9!9 > > :j%00>*11$z2B2BCCCC*11*====')9:: F 0 ? N T T V VFFHAu!*e44F.556Q6Q56Q6Q6QRRRR.55enEEEE5  :  (0@ @ @ LL(dj2;((TXT](($(((      A @r,c td)aG _sanitize_parameters will be called with any excessive named arguments from either `__init__` or `__call__` methods. It should return 3 dictionnaries of the resolved parameters used by the various `preprocess`, `forward` and `postprocess` methods. Do not fill dictionnaries if the caller didn't specify a kwargs. This let's you keep defaults in function signatures, which is more "natural". It is not meant to be called directly, it will be automatically called and the final parameters resolved by `__init__` and `__call__` z$_sanitize_parameters not implementedr)rpipeline_parameterss r*rCzPipeline._sanitize_parameterss""HIIIr,input_preprocess_parametersrc td)z Preprocess will take the `input_` of a specific pipeline and return a dictionary of everything necessary for `_forward` to run properly. It should contain at least one tensor, but might have arbitrary other items. zpreprocess not implementedr)rrrs r* preprocesszPipeline.preprocesss "">???r, input_tensorsforward_parametersc td)a _forward will receive the prepared dictionary from `preprocess` and run it on the model. This method might involve the GPU or the CPU and should be agnostic to it. Isolating this function is the reason for `preprocess` and `postprocess` to exist, so that the hot path, this method generally can run as fast as possible. It is not meant to be called directly, `forward` is preferred. It is basically the same but contains additional code surrounding `_forward` making sure tensors and models are on the same device, disabling the training part of the code (leading to faster inference). z_forward not implementedr)rrrs r*_forwardzPipeline._forwards""<===r, model_outputspostprocess_parametersc td)a Postprocess will receive the raw outputs of the `_forward` method, generally tensors, and reformat them into something more friendly. Generally it will output a list or a dict or results (containing just strings and numbers). zpostprocess not implementedr)rrrs r* postprocesszPipeline.postprocesss""?@@@r,ctjSr)rKno_gradrs r*get_inference_contextzPipeline.get_inference_contexts }r,c |5|jdkrd|d<|j|fi|}n|jdkr|}|5|||j}|j|fi|}||t jd}dddn #1swxYwYntd|jddddn #1swxYwY|S) Nr|Ftrainingr{)r/r4z Framework z is not supported)rarwrrrcr/rKr()r model_inputsforward_paramsrinference_contexts r*forwardzPipeline.forwards  " " $ $ Q Q~%%+0 Z( - l M Mn M M 4''$($>$>$@$@!&&((mm#'#@#@VZVa#@#b#bL$1DM,$Q$Q.$Q$QM$($A$A-X]XdejXkXk$A$l$lMmmmmmmmmmmmmmmm !!Odn!O!O!OPPP Q Q Q Q Q Q Q Q Q Q Q Q Q Q Qs7A C.AB>2 C.>C C.C C..C25C2r5rUc@t|tjjrt ||j|}n8|dkrt dd}t||j|}dtj vr)t ddtj d<|j |j n|j }|dkrtnt|j|} t#|||| } t| |j||} t| |j|} | S)Nr"zFor iterable dataset using num_workers>1 is likely to result in errors since everything is iterable, setting `num_workers=1` to guarantee correctness.TOKENIZERS_PARALLELISMNDisabling tokenizer parallelism, we're using DataLoader multithreading alreadyfalser5rU collate_fnloader_batch_size)rJ collectionsabcSizedr'rrrr(renvironrWrkr,r+rsrmrrr rrdr5rUpreprocess_paramsrpostprocess_paramsdatasetrkr dataloadermodel_iteratorfinal_iterators r* get_iteratorzPipeline.get_iterators! fko3 4 4 S%fdo?PQQGGQ1  &vt@QRRG #2: 5 5 KKh i i i3:BJ/ 06:6L6XD22^b^r&0Aoo]]>$.Zk;l;l [Zdnooo )*dlNfpqqq).$:JL^__r,)r5rUc ,|rtd|||jd}n|j}||jd}n|j}|jdi|\}}}i|j|}i|j|}i|j|}|xjdz c_|jdkr5|j dkr*|j j dkrtj dttduot!|t} t!|t"j} t!|t&} | p| p| } |j dko| p| p| } | rE| r+|||||||}t'|}|S|||||S| r|||||||S| r|||||S|j dkrJt!|t.r5t1t3||g|||||S|||||S) NzIgnoring args : rr" r{r_zlYou seem to be using the pipelines sequentially on GPU. In order to maximize efficiency please use a datasetr1)rrrBrArCrDrErFr?rwr/r`rr UserWarningr rJtypes GeneratorTyperr run_multiiterate ChunkPipeliner8r9 run_single)rrdr5rUrrrrr is_dataset is_generatoris_list is_iterablecan_use_iteratorroutputss r*rzPipeline.__call__*s  6 NN4d44 5 5 5   ( "/  ' !- @Y@Y@c@c\b@c@c=>+=Mt6L:KLCD0CNCO 8O> VT** ;L;G  >T1]z7\\7\U\  b e!%!2!2K5FXj""~..~~f.?Qcddd  b$$ Z1BNTf  b<<(9>K]^^ ^ ^t # # 4(G(G #%%+z;Ln^p ??6+.ls.pppae&7I[\\pppr,r1)rrdrrrs` ```r*rzPipeline.run_multiks*pppppppioppppr,cZ|j|fi|}|j|fi|}|j|fi|}|Sr)rrr)rrdrrrrrrs r*rzPipeline.run_singlensU&tvCC1BCC $ \DD^DD "$"=GG4FGGr,c#HK|D]}|||||VdSrr)rrdrrrrs r*rzPipeline.iteratetsH a aF//&*;^M_`` ` ` ` ` a ar,) NNNNNrNNNFr)*rrrrdefault_input_namesrr rrrrrrr6rrrUr#r%rrarercr rr|rrCr r rrrrrrrrrrrrr1r,r*r+r+sA  48BF8<)-#''+-1;?#M>M>;<M>/0M>$$>? M> ""45 M> I& M>C=M>M>%M>c>)*M>eC$678M>M>M>M>M>^-;-;c-;t-;-;-;-;^  ^4 B B B(tCy$1G: J J^ J@@t@SR_M_H`@@@^@ >d3 +=&> >VZ >_j > > >^ >AAPTAY\AAA^A   #&472374?b?b?b?b?bBqqq aaaaar,r+c$eZdZdZdedefdZdS)rcg}|j|fi|D]%}|j|fi|}||&|j|fi|}|Sr)rrrr) rrdrrr all_outputsrrrs r*rzChunkPipeline.run_single|s{ +DOFHH6GHH . .L(DLHHHHM   } - - - -"$";EE2DEEr,r5rUcdtjvr)tddtjd<|dkrtdd}t ||j|}|j|jn|j}|dkrtnt|j |} t|||| } t| |j||} t| |j|} | S)Nrrrr"zFor ChunkPipeline using num_workers>0 is likely to result in errors since everything is iterable, setting `num_workers=1` to guarantee correctness.rr)rrrrWrr&rrkr,r+rsrmrr)rr(rrs r*rzChunkPipeline.get_iterators $2: 5 5 KKh i i i3:BJ/ 0 ?? NNE   K'ARSS7;6L6XD22^b^r&0Aoo]]>$.Zk;l;l [Zdnooo -j$,jtuuu).$:JL^__r,N)rrrrr6rr1r,r*rr{sG#&47r,rceZdZdeeefdeeefddfdZdeefdZdede eeeffdZ dded e d e e e e e fd e e e e e fd e ed e eddfdZdZdS)PipelineRegistrysupported_tasks task_aliasesrNc"||_||_dSr)rr)rrrs r*rzPipelineRegistry.__init__s.(r,ct|jt|jz}||Sr)rrrgrsort)rsupported_tasks r*get_supported_tasksz$PipelineRegistry.get_supported_taskssRd27799::T$BSBXBXBZBZ=[=[[r,rvc||jvr |j|}||jvr|j|}||dfS|dru|d}t |dkr:|ddkr.|ddkr"|jd}d}|||d|dffSt d |d t d |d |d gz)N translationrr9rrr7r"rEzInvalid translation task z#, use 'translation_XX_to_YY' formatz Unknown task z, available tasks are translation_XX_to_YY)rr startswithrr'rr)rrvrtokenss r* check_taskzPipelineRegistry.check_tasks 4$ $ $$T*D 4' ' ' 06M, , ??= ) ) bZZ__F6{{aF1I$>$>6!9PTCTCT $ 4] C $]VAYq ,BBB`t```aa a oD o o8P8P8R8RVlUm8m o o   r,pipeline_classpt_modeltf_modelrr`c:||jvr t|d|d|d}nt|ts|f}|d}nt|ts|f}|||d}|d|vr d|vsd|vrd|i}||d<|||d <||j|<||i|_dS) Nz6 is already registered. Overwriting pipeline for task z...r1)rLr{r|rr{r|rr`)rrrrJrrK)rrvrrrrr` task_impls r*register_pipelinez"PipelineRegistry.register_pipelines 4' ' ' NNdccZ^ccc d d d  HHHe,, # {H  HHHe,, # {H+88LL  g%%47??dgoo"G,#*Ii   $If %.T"+/*;'''r,c|jSr)rrs r*to_dictzPipelineRegistry.to_dicts ##r,)NNNN)rrrr rr rr rrrr`r rrrr1r,r*rrsD)S#X)d3PS8n)Y]))))T#Y  s uS$^'<    .8<7;"&"!<!<!<!<5uT{!234 !< 5uT{!234 !< $ !<sm!< !<!<!<!rs+  ######## %%%%%%########IIIIIIIIIIIIIIIIII555555AAAAAA777777!!!!!!777777444444rrrrrrrrrrrrrrrrd?+^[HI ?;:::::: LLL44444444555555%$$$$$$GJ1555555000000  H % % /-/-/-d<<<D7;# __ _DeDk!123_ 3- _ } ____H7;# $$DeDk!123$ 3-$} $$$$N8C=D)%)%$,SM)%AI#)% 3c3h  )%)%)%)%X "$$$$$c$$$n\n\n\n\n\n\n\n\b)')')')')'.)')')'X'''''/'''T-)-)-)-)-)0-)-)-)` $ $ $ $ $C $ $ $!F&''[a[a[a[a[a}[a[a('[a| H@A$A$A$A$A$A$A$A$A$A$r,