o  h @s>ddlZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl m Z m Z ddlmZddlmZddlmZmZddlmZmZmZmZmZmZmZddlmZdd lmZdd l m!Z!dd l"m#Z#dd l$m%Z%m&Z&dd l'm(Z(ddl)m*Z*ddl+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:eedddfZ;e1rddlm?Z?e2rddl@Z@ddlAmBZBmCZCddlDmEZEddlFmGZGddlHmIZIndZCdZIerddlJmKZKddlDmEZEe:LeMZNddZOddZPddZQ   d\d e%d!eeeReeSfd"eeRd#eeRfd$d%ZT   d\d!eeeReeSfd"eeRd#eeRfd&d'ZUd]d(eeRfd)d*ZVd+ed#eeRd,eed-eeReRffd.d/ZWd0d1d2eeeRd1fd3ee*d-eed1ee*ffd4d5ZXGd6d7d7eYZZGd8d9d9e Z[Gd:d;d;Z\Gdd?d?e\Z^Gd@dAdAe\Z_GdBdCdCe Z` D D D D Ed^dFeadGeadHeadIeadJead-eRf dKdLZbebdEdEdEdEdEdMZce2rddNldmeZemfZfmgZgmhZhe.ebdEdEdEdEdOGdPdQdQe`e-Zie/eijjei_jeijjjkdureijjjkjldRdSdTdUmdVdWeijj_kGdXdYdYeiZnGdZd[d[ZodS)_N)ABCabstractmethod)UserDict)contextmanager)abspathexists) TYPE_CHECKINGAnyDictListOptionalTupleUnion)custom_object_save)PreTrainedFeatureExtractor)BaseImageProcessor) ModelCard) AutoConfig AutoTokenizer)ProcessorMixin)PreTrainedTokenizer) ModelOutputPushToHubMixinadd_end_docstrings copy_funcinfer_frameworkis_tf_availableis_torch_availableis_torch_cuda_availableis_torch_hpu_availableis_torch_mlu_availableis_torch_mps_availableis_torch_musa_availableis_torch_npu_availableis_torch_xpu_availablelogging GenericTensorz torch.Tensorz tf.Tensor) TFAutoModel) DataLoaderDataset)PreTrainedModel) AutoModel) KeyDataset)TFPreTrainedModelcCst|dkr td|dS)Nr-z5This collate_fn is meant to be used with batch_size=1r)len ValueError)itemsr3o/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/transformers/pipelines/base.py no_collate_fnVs r5c st|}t|dtjrt|dj}t|}|dkr,tjfdd|DddSdvr>tjfdd|DddS|dkrTd krTtjfd d|DddStfd d |D}tfd d |D}|dj} |dkr||krtjfdd|DddStj ||f| d|} n(|dkrtj |||df| d|} n|dkrtj |||d|df| d|} t |D]\} } |dkr|dkr| d | | t| d df<q| d | | dt| df<q|dkr1|dkr| d | | t| d dddf<q| d | | dt| dddf<q|dkrq|dkrW| d | | t| d dddddf<q| d | | dt| dddddf<q| Sfdd|DS)Nrr-cg|]}|qSr3r3.0itemkeyr3r4 dz_pad..)dim) pixel_valuesimagecr6r3r3r7r:r3r4r<hr=input_featurescr6r3r3r7r:r3r4r<kr=c3|] }|jdVqdSr-Nshaper7r:r3r4 lz_pad..c3rCrDrEr7r:r3r4rGmrHrcr6r3r3r7r:r3r4r<tr=)dtypeleftcr6r3r3r7r:r3r4r<r=) r0 isinstancetorchTensorrFcatmaxminrIzeros enumerateclone) r2r; padding_value padding_side batch_sizerFr> max_length min_lengthrItensorir9r3r:r4_pad\sJ",*  20  84r^csd}d}durdurtddur#jdurtdjj}dur3tddtdd}|durI|durI||krItd|d|d|durQ||durW|fdd }|S) NzBPipeline without tokenizer or feature_extractor cannot do batchingzPipeline with tokenizer without pad_token cannot do batching. You can try to set it with `pipe.tokenizer.pad_token_id = model.config.eos_token_id`.rWrXzAThe feature extractor, and tokenizer don't agree on padding side  != rightcst|d}|D]}t||kr#tdt|d|dq i}|D]4}|dvr<dur9dur9}n}n|dvrC}n|dvrJd}n |d vrQd}nd}t|||||<q(|S) NrzEThe elements of the batch contain different keys. Cannot batch them (r_)> input_ids> input_valuesr?rB>p_maskspecial_tokens_maskr->attention_masktoken_type_ids)setkeysr1r^)r2rir9paddedr;_padding_valuef_padding_valuefeature_extractorrXt_padding_value tokenizerr3r4inners0zpad_collate_fn..inner)r1 pad_token_idrXgetattr)rprnt_padding_sidef_padding_siderqr3rlr4pad_collate_fns2   rvconfig model_classestask frameworkc Ks&ts ts tdt|tr||d<d}to|dv}to#|dv}|r<|r1||dtf}|r<||dtf}|jrwg} |jD],} t d} |r\t | | d } | d ur\| | |rpt | d | d } | d urp| | qD|t | }t|d krtd |i} |D]R}|}|dkr|d rd|d<tdn|dkr|drd|d<tdz|j|fi|}t|dr|}Wnttfyt| |j<Yqwt|trd}| D]\}}|d|d|d7}qtd|d|d|d|d urt|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_pipeliner3>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.evalzwhile loading with z, an error is thrown:  zCould not load model z$ with any of the following classes: z. See the original errors: )rr RuntimeErrorrNstrgetr,r( architectures importlib import_modulersappendtupler0r1copyendswithloggerwarningfrom_pretrainedhasattrrOSError traceback format_exc__name__r2r __class__)modelrwrxryrz model_kwargs class_tuplelook_ptlook_tfclasses architecturetransformers_module_class all_traceback model_classkwargserror class_nametracer3r3r4infer_framework_load_models| !            rcKsDt|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. r|)rxr|ryrz)rNrrrrwr)rrxryrzrrwr3r3r4infer_framework_from_model9s rrevisioncCstdttststdt|trKtr#ts#tj ||d}n(tr1ts1t j ||d}nz tj ||d}Wnt yJt j ||d}Ynwt |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.r{)r)warningswarn FutureWarningrrrrNrr,rr(rrr)rrrzr3r3r4 get_framework`s(       r targeted_task task_optionsreturncCstr ts d}ntrtsd}|d}|r)||vr"td|||d}nd|vr4|dd}ntd|dur>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 Tuple: - `str` The model string representing the default model for this pipeline. - `str` The revision of the model. 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"N)rrr1)rrzrdefaultsdefault_modelsr3r3r4get_default_model_and_revisions  rrr+assistant_modelassistant_tokenizercsr|dur dStddksttstdt|tr;t|}t||d\}j j j dt |}n||}j jj jk}tfdd d D}|r]|r]d}|fS|duretd |fS) a Prepares the assistant model and the assistant tokenizer for a pipeline whose model that can call `generate`. Args: model ([`PreTrainedModel`]): The main model that will be used by the pipeline to make predictions. assistant_model (`str` or [`PreTrainedModel`], *optional*): The assistant model that will be used by the pipeline to make predictions. assistant_tokenizer ([`PreTrainedTokenizer`], *optional*): The assistant tokenizer that will be used by the pipeline to encode data for the model. Returns: Tuple: The loaded assistant model and (optionally) the loaded tokenizer. N)NNrzr}zAssisted generation, triggered by the `assistant_model` argument, is only available for `PreTrainedModel` model instances. For instance, TF or JAX models are not supported.rw)devicerIc3s(|]}tj|tj|kVqdSN)rsrw)r8tokenloaded_assistant_modelrr3r4rGs  z'load_assistant_model..) eos_token_idrr bos_token_idzkThe assistant model has a different tokenizer than the main model. You should pass the assistant tokenizer.) can_generatersrNr+r1rrrrtorrIrrw vocab_sizeall)rrrassistant_config_loaded_assistant_tokenizersame_vocab_sizesame_special_tokensr3rr4load_assistant_models2   rcs.eZdZdZdededeffdd ZZS)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. ryrreasoncst|||_||_dSr)super__init__ryr)selfryrrrr3r4rs  zPipelineException.__init__)r __module__ __qualname____doc__rr __classcell__r3r3rr4rs" rc@seZdZdZeddZdS)ArgumentHandlerzQ Base interface for handling arguments for each [`~pipelines.Pipeline`]. cOtrNotImplementedError)rargsrr3r3r4__call__zArgumentHandler.__call__N)rrrrrrr3r3r3r4rsrc @seZdZdZgdZ ddeedeedeedefdd Ze d d Z e d e e e e ffd dZd e e e e fdefddZe ddedeedeedeeddf ddZdS)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`): Where to save the outgoing data. input_path (`str`): Where to look for the input data. column (`str`): The column to read. overwrite (`bool`, *optional*, defaults to `False`): Whether or not to overwrite the `output_path`. )jsoncsvpipeF output_path input_pathcolumn overwritecCs||_||_|dur|dndg|_t|jdk|_|jr'dd|jD|_|dur<|s.z already exists on diskz doesnt exist on disk) rrrrr0is_multi_columnsrrrrrrrrr3r3r4rs zPipelineDataFormat.__init__cCrrrrr3r3r4__iter__0rzPipelineDataFormat.__iter__datacCr)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. rrrr3r3r4save4szPipelineDataFormat.savercCs`tj|j\}}tjj|df}t|d}t||Wd|S1s)wY|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)rrrr binary_pathf_outputr3r3r4 save_binary>s   zPipelineDataFormat.save_binaryformatcCsX|dkr t||||dS|dkrt||||dS|dkr$t||||dStd|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)rrrrrr3r3r4from_strPszPipelineDataFormat.from_strNF)rrrrSUPPORTED_FORMATSr rboolrrrrdictr rr staticmethodrr3r3r3r4rs>   rcsXeZdZdZ d deedeedeeffdd Zdd Zd ee fd d Z Z S)raa Support for pipelines using CSV data format. Args: output_path (`str`): Where to save the outgoing data. input_path (`str`): Where to look for the input data. column (`str`): The column to read. overwrite (`bool`, *optional*, defaults to `False`): Whether or not to overwrite the `output_path`. Frrrcstj||||ddS)Nr)rrrrr3r4rszCsvPipelineDataFormat.__init__c#svt|jd*}t|}|D]|jr fdd|jDVq|jdVqWddS1s4wYdS)Nrci|] \}}||qSr3r3r8krrowr3r4 z2CsvPipelineDataFormat.__iter__..r)rrr DictReaderrr)rfreaderr3r r4rs "zCsvPipelineDataFormat.__iter__rcCsxt|jd,}t|dkr*t|t|d}|||WddSWddS1s5wYdS)z Save the provided data object with the representation for the current [`~pipelines.PipelineDataFormat`]. Args: data (`List[dict]`): The data to store. wrN) rrr0r DictWriterlistri writeheader writerows)rrrwriterr3r3r4rs  "zCsvPipelineDataFormat.saver) rrrrr rrrr rrrr3r3rr4rts  rcsTeZdZdZ d deedeedeeffdd Zdd Zd efd d Z Z S)rab Support for pipelines using JSON file format. Args: output_path (`str`): Where to save the outgoing data. input_path (`str`): Where to look for the input data. column (`str`): The column to read. overwrite (`bool`, *optional*, defaults to `False`): Whether or not to overwrite the `output_path`. FrrrcsPtj||||dt|d}t||_WddS1s!wYdS)Nrr)rrrrload_entries)rrrrrrrr3r4rs "zJsonPipelineDataFormat.__init__c#s@|jD]|jrfdd|jDVq|jdVqdS)Ncrr3r3rentryr3r4r r z3JsonPipelineDataFormat.__iter__..r)rrrrr3rr4rs  zJsonPipelineDataFormat.__iter__rcCs>t|jd}t||WddS1swYdS)z| Save the provided data object in a json file. Args: data (`dict`): The data to store. rN)rrrr)rrrr3r3r4rs"zJsonPipelineDataFormat.saver) rrrrr rrrrrrr3r3rr4rs rcsLeZdZdZddZdefddZdeeeefde ffdd Z Z 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`): Where to save the outgoing data. input_path (`str`): Where to look for the input data. column (`str`): The column to read. overwrite (`bool`, *optional*, defaults to `False`): Whether or not to overwrite the `output_path`. ccsVtjD]$}d|vr%|d}|jrddt|j|DVqt|Vq|VqdS)N cSsi|] \\}}}||qSr3r3)r8rrlr3r3r4r r z4PipedPipelineDataFormat.__iter__..)sysstdinrrzipr)rliner3r3r4rs   z PipedPipelineDataFormat.__iter__rcCs t|dS)z^ Print the data. Args: data (`dict`): The data to store. N)printrr3r3r4rs zPipedPipelineDataFormat.savercs|jdur tdt|S)NzWhen using piped input on pipeline outputting large object requires an output file path. Please provide such output path through --output argument.)rrrrrrr3r4rs  z#PipedPipelineDataFormat.save_binary) rrrrrrrrr rrrr3r3rr4rs  * rc@s(eZdZdZeddZeddZdS) _ScikitCompatzA Interface layer for the Scikit and Keras compatibility. cCrrrrXr3r3r4 transformrz_ScikitCompat.transformcCrrrr#r3r3r4predictrz_ScikitCompat.predictN)rrrrrr%r&r3r3r3r4r"s  r"FT has_tokenizerhas_feature_extractorhas_image_processor has_processorsupports_binary_outputcCsLd}|r|d7}|r|d7}|r|d7}|r|d7}|d7}|r$|d7}|S)Na 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.z tokenizer ([`PreTrainedTokenizer`]): The tokenizer that will be used by the pipeline to encode data for the model. This object inherits from [`PreTrainedTokenizer`].z feature_extractor ([`SequenceFeatureExtractor`]): The feature extractor that will be used by the pipeline to encode data for the model. This object inherits from [`SequenceFeatureExtractor`].z image_processor ([`BaseImageProcessor`]): The image processor that will be used by the pipeline to encode data for the model. This object inherits from [`BaseImageProcessor`].a4 processor ([`ProcessorMixin`]): The processor that will be used by the pipeline to encode data for the model. This object inherits from [`ProcessorMixin`]. Processor is a composite object that might contain `tokenizer`, `feature_extractor`, and `image_processor`.ak 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 torch_dtype (`str` or `torch.dtype`, *optional*): Sent directly as `model_kwargs` (just a simpler shortcut) to use the available precision for this model (`torch.float16`, `torch.bfloat16`, ... or `"auto"`)z binary_output (`bool`, *optional*, defaults to `False`): Flag indicating if the output the pipeline should happen in a serialized format (i.e., pickle) or as the raw output data e.g. text.r3)r'r(r)r*r+ docstringr3r3r4build_pipeline_init_argssr-)r'r(r)r*r+)PipelineChunkIteratorPipelineDatasetPipelineIteratorPipelinePackIterator)r'r(r)r*c@seZdZdZdZdZdZdZdZ           dJde dde e d e e d e e d e ed e ed e ededede edfde e edfdefddZ dKde eejfdefddZddZddZede dfd d!Zed"d#Zd$d%Zd&d'Zd(e e ee!ffd)d*Z"e#d+d,Z$e#d-e%d.e&de&ee'ffd/d0Z(e#d1e&ee'fd2e&de)fd3d4Z*e#d5e)d6e&de%fd7d8Z+d9d:Z,d;d<Z-d=ed>efd?d@Z.dddAdBdCZ/dDdEZ0dFdGZ1dHdIZ2dS)LPipelinea 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. FTNrr)r+r/rprnimage_processor processor modelcardrzry args_parserrz torch.device torch_dtypez torch.dtype binary_outputc Ks|dur t||jd\}}||_||_||_||_||_||_||_||_ t |jdd}|dur8| dur8t d| durK|durIt t |} nd} tr|j dkr| dkrc|jjdurc|jj} t| tjr| jdkrstdd r{| jd krtst | d | |_nt| trd| vrtdd rd | vrtst | d t| |_n{| dkrtd |_nptrtd | |_nctrtd| |_nVtrtd| |_nItrtd| |_nt|jt9r@|j|_dSdSdSdS)Nr 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.rr}rKxpuT) check_devicehpuz6 is not available, you should use device="cpu" insteadcpuzmlu:zmusa:zcuda:znpu:zhpu:zxpu:zmps:zDevice set to use rrprefixrY num_workersrprnr3r3):rrwryrrprnr3r4r5rzrsr1nextitervaluesrrrNrOtyper%r rr!r#rr$r" distributedis_initializedrrr8intrrpoprrrrr>rdeepcopygeneration_configtask_specific_paramsrupdaterr call_count _batch_size _num_workers_sanitize_parameters_preprocess_params_forward_params_postprocess_paramsrr)rrrprnr3r4r5rzryr6rr7r8rr9rJthis_task_paramsr3r3r4rs                  zPipeline.__init__save_directorysafe_serializationc Ks|dd}|dur tdt|dddurtd||d<tj|r1t d|ddStj |dd t |d r|j }i}|D]F\}}|d |jkrTqH|}|d j} | d d } | d |d j|d <tdd|dD|d<tdd|dD|d<|||<qH||jj_t||||d<|jj|fi||jdur|jj|fi||jdur|jj|fi||jdur|jj|fi||jdur|j|dSdS)a Save the pipeline's model and tokenizer. Args: save_directory (`str` or `os.PathLike`): 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. kwargs (`Dict[str, Any]`, *optional*): Additional key word arguments passed along to the [`~utils.PushToHubMixin.push_to_hub`] method. use_auth_tokenNzrThe `use_auth_token` argument is deprecated and will be removed in v5 of Transformers. Please use `token` instead.rzV`token` and `use_auth_token` are both specified. Please set only the argument `token`.zProvided path (z#) should be a directory, not a fileT)exist_ok_registered_implimpl.rKcs|]}|jVqdSrrrr3r3r4rGDz+Pipeline.save_pretrained..r}csr[rr\rr3r3r4rGEr]r~rU)rGrrrrr1rrisfilerrmakedirsrrXrr2rrrrrrrwcustom_pipelinesrsave_pretrainedrprnr3r5) rrTrUrrV pipeline_infor`ryinfo module_name last_moduler3r3r4rasR            zPipeline.save_pretrainedcC||Szn Scikit / Keras interface to transformers' pipelines. This method will forward to __call__(). r3r#r3r3r4r%[zPipeline.transformcCrfrgr3r#r3r3r4r&arhzPipeline.predictrcCst|jddS)zU Torch dtype of the model (if it's Pytorch model), `None` otherwise. rIN)rsrrr3r3r4r7gszPipeline.torch_dtypeccsz|jdkr,t|jdkrdnd|j dVWddS1s%wYdS|jjdkrOtj|j dVWddS1sHwYdS|jjdkrrtj|j dVWddS1skwYdS|jjdkrtj|j dVWddS1swYdS|jjd krtj|j dVWddS1swYdSdVdS) 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~rKz/CPU:0z /device:GPU:Ncudamlumusar:) rzr~rrCrOrirjrkr:rr3r3r4device_placementns, "" " " " " zPipeline.device_placementcKs|||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)rinputsr3r3r4ensure_tensor_on_devices z Pipeline.ensure_tensor_on_devicecst|trtfdd|DSt|tr$fdd|DSt|tr7tfdd|DSt|trFfdd|DSt|trWtfdd|DSt|tjrb| S|S)Nci|] \}}||qSr3rmr8namer\rrr3r4r z5Pipeline._ensure_tensor_on_device..crpr3rqrrrtr3r4r rucrpr3rqrrrtr3r4r rucg|]}|qSr3rqr7rtr3r4r<z5Pipeline._ensure_tensor_on_device..crvr3rqr7rtr3r4r<rw) rNrr2rrrrrOrPr)rrnrr3rtr4rms       z!Pipeline._ensure_tensor_on_devicesupported_modelsc Cst|tsJg}|D]\}}t|tr|t|q ||q t|drH|jjD]\}}t|trA|dd|Dq-||j q-|}|j j j |vrft 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_mappingcSsg|]}|jqSr3r\)r8mr3r3r4r<sz-Pipeline.check_model_type..z The model 'z' is not supported for z. Supported models are rZN)rNrr2rextendrrry_extra_contentrrrrrry)rrxsupported_models_namesr model_namerr3r3r4check_model_types&     zPipeline.check_model_typecKtd)aD _sanitize_parameters will be called with any excessive named arguments from either `__init__` or `__call__` methods. It should return 3 dictionaries of the resolved parameters used by the various `preprocess`, `forward` and `postprocess` methods. Do not fill dictionaries if the caller didn't specify a kwargs. This lets 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_parametersr3r3r4rO zPipeline._sanitize_parametersinput_preprocess_parameterscKr)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)rrrr3r3r4 preprocessszPipeline.preprocess input_tensorsforward_parameterscKr)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)rrrr3r3r4_forwardrzPipeline._forward model_outputspostprocess_parameterscKr)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)rrrr3r3r4 postprocessszPipeline.postprocesscCstjSr)rOno_gradrr3r3r4get_inference_contextzPipeline.get_inference_contextc Ks|e|jdkrd|d<|j|fi|}nA|jdkrP|}|#|j||jd}|j|fi|}|j|tdd}Wdn1sJwYntd|jdWd|SWd|S1slwY|S) Nr~Ftrainingr})rr=z Framework z is not supported)rlrzrrrmrrOr1)r model_inputsforward_paramsrinference_contextr3r3r4forwards*        zPipeline.forwardr?rYc Cst|tjjrt||j|}n|dkrtdd}t||j|}dt j vr0t ddt j d<|j dur8|j n|j }|dkrAtnt|j|} t|||| d} t| |j||d} 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 alreadyfalser?rY collate_fnloader_batch_size)rN collectionsabcSizedr/rrrr0renvironrcrnr3r5rvrpr)rr rrnr?rYpreprocess_paramsrpostprocess_paramsdatasetrnr dataloadermodel_iteratorfinal_iteratorr3r3r4 get_iterator s"   zPipeline.get_iterator)r?rYc Os|r td||dur|jdurd}n|j}|dur(|jdur%d}n|j}|jdi|\}}}i|j|}i|j|}i|j|}|jd7_|jdkrd|j dkrd|j j dkrdt dt duolt|t } t|tj} t|t} | p}| p}| } |j dko| p| p| } | r| r|||||||}t|}|S|||||S| r|||||||S| r|||||S|j dkrt|trtt||g|||||S|||||S) NzIgnoring args : rr- r}rizlYou seem to be using the pipelines sequentially on GPU. In order to maximize efficiency please use a datasetr3)rrrNrMrOrPrQrRrLrzrrC warning_oncer*rNtypes GeneratorTyperr run_multiiterate ChunkPipeliner@rA run_single)rrnr?rYrrrrr is_dataset is_generatoris_list is_iterablecan_use_iteratorroutputsr3r3r4r%s^        zPipeline.__call__csfdd|DS)Ncsg|] }|qSr3rr7rrrrr3r4r<fsz&Pipeline.run_multi..r3)rrnrrrr3rr4reszPipeline.run_multicCs:|j|fi|}|j|fi|}|j|fi|}|Sr)rrr)rrnrrrrrrr3r3r4rhszPipeline.run_singleccs"|D] }|||||VqdSrr)rrnrrrrr3r3r4rnszPipeline.iterate) NNNNNNrNNNF)T)3rrrr_load_processor_load_image_processor_load_feature_extractor_load_tokenizerdefault_input_namesrr rrrrrrrrFrrrPathLikerar%r&propertyr7rrlrormr rrrrOr r r'rrrrrrrrrrrr3r3r3r4r2^s       G #     @ r2rpipelinez pipeline file)object object_class object_filesz.from_pretrainedrc@s&eZdZddZdedefddZdS)rc CsNg}|j|fi|D]}|j|fi|}||q |j|fi|}|Sr)rrrr) rrnrrr all_outputsrrrr3r3r4r}s  zChunkPipeline.run_singler?rYc Csdtjvrtddtjd<|dkrtdd}t||j|}|jdur)|jn|j}|dkr2t nt |j |} t |||| d} t | |j||d} 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)rrrrcrr.rrnr3r5rvrpr)r1rr0rrr3r3r4rs   zChunkPipeline.get_iteratorN)rrrrrFrr3r3r3r4r|src@seZdZdeeefdeeefddfddZdeefddZd ede eeeffd d Z    dd ed e d e e e e e fde e e e e fde ede eddfddZddZdS)PipelineRegistrysupported_tasks task_aliasesrNcCs||_||_dSr)rr)rrrr3r3r4rs zPipelineRegistry.__init__cCs(t|jt|j}||Sr)rrrirsort)rsupported_taskr3r3r4get_supported_taskssz$PipelineRegistry.get_supported_tasksrycCs||jvr |j|}||jvr|j|}||dfS|drO|d}t|dkrG|ddkrG|ddkrG|jd}d}|||d|dffStd |d td |d |d g)N translationrrArrrr-rJzInvalid translation task z#, use 'translation_XX_to_YY' formatz Unknown task z, available tasks are translation_XX_to_YY)rr startswithrr0rr)rryrtokensr3r3r4 check_tasks       $ zPipelineRegistry.check_taskpipeline_classpt_modeltf_modelrrCcCs||jvrt|d|d|durd}nt|ts|f}|dur&d}nt|ts.|f}|||d}|durLd|vrHd|vsDd|vrHd|i}||d<|durT||d <||j|<||i|_dS) Nz6 is already registered. Overwriting pipeline for task z...r3)rYr}r~rr}r~rrC)rrrrNrrX)rryrrrrrC task_implr3r3r4register_pipelines&     z"PipelineRegistry.register_pipelinecCs|jSr)rrr3r3r4to_dictrzPipelineRegistry.to_dict)NNNN)rrrr rr rr rr rrCr rrrr3r3r3r4rs0& #r)NNNr)FFFFT)prrrrrrrrrrrrrrr contextlibros.pathrrtypingrr r r r r rdynamic_module_utilsrfeature_extraction_utilsrimage_processing_utilsrr5r models.autorrprocessing_utilsrtokenization_utilsrutilsrrrrrrrrr r!r"r#r$r%r&r' tensorflowr~models.auto.modeling_tf_autor(rOtorch.utils.datar)r*modeling_utilsr+models.auto.modeling_autor,pt_utilsr.modeling_tf_utilsr/ get_loggerrrr5r^rvrrCrrrrr Exceptionrrrrrrr"rr-PIPELINE_INIT_ARGStransformers.pipelines.pt_utilsr.r/r0r1r2 push_to_hubrrreplacerrr3r3r3r4s  $      D      5B k '"  . 8 q,*0 D