/usr/local/lib/python3.6/site-packages/transformers/pipelines/__pycache__
Edit: /usr/local/lib/python3.6/site-packages/transformers/pipelines/__pycache__/base.cpython-36.pyc (38065B)
3
Eg @ s d dl Z d dlZd dlZd dlZd dlZd dlZd dlZd dlZd dlZd dl m
Z
m Z d dl m Z d dl
mZ d dlmZmZ d dlmZmZmZmZmZmZmZ d dlmZ dd l m Z dd
l m Z dd l m!Z! dd l"m#Z# dd
l$m%Z%m&Z&m'Z'm(Z(m)Z) eed ddf Z*e' r*d dl+Z,ddl-m.Z. e( rdd dl/Z/d dl0m1Z1m2Z2 ddl3m4Z4 ddl5m6Z6 ndZ2dZ6erddl7m8Z8 ddl9m:Z: e)j;e<Z=dd Z>dd Z?d d Z@d>e!eeeAeeB f eeA eeA d d d ZCd?eeeAeeB f eeA eeA d!d"d#ZDd@eeA d$d%d&ZEeeeA ee eAd'd(d)ZFG d*d+ d+eGZHG d,d- d-e
ZIG d.d/ d/ZJG d0d1 d1eJZKG d2d3 d3eJZLG d4d5 d5eJZMG d6d7 d7e
ZNd8ZOe( rd d9lPmQZQmRZRmSZSmTZT e&eOG d:d; d;eNZUG d
Q s z_pad..)dimc 3 s | ]}| j d V qdS )r N)shape)r* r+ )r, r& r' R s z_pad..r )dtype r leftc s g | ] }| qS r& r& )r* r+ )r, r& r' r- g s ) r#
isinstancetorchTensorr/ catmaxr1 Zzeros enumerateclone) r% r,
padding_value padding_side
batch_sizer/ r.
max_lengthr1 tensorir+ r& )r, r' _padH s.
,*
22rB c s d }d }| d kr |d kr t d| d k rH| jd kr rE > rF rH rG > rI rJ > rL rK )setkeysr$ rB )r% rN r+ Zpaddedr, Z_padding_value)f_padding_valuer= t_padding_valuer& r' inner s$
z pad_collate_fn..inner)r$ Z pad_token_idr= getattr) tokenizerfeature_extractorZt_padding_sideZf_padding_siderQ r& )rO r= rP r' pad_collate_fnj s.
rU )config
model_classestask frameworkc
K s t rt rtdt| tr||d< f }t o<|dk}t oJ|dk}|r||rf||jdtf }|r|||jdtf }|jrg } xb|jD ]X}
t j
d} |rt | |
d} | dk r| j | |rt | d|
d} | dk r| j | qW |t
| }t|dkrtd | x|D ]}
|j }|dkrN| jd
rNd |d < tjd
n(|dkrv| jdrvd |d< tjd y(|
j| f|} t| dr| j } P W n ttfk
r wY nX qW t| trtd| d| d| jjjdrdnd}|| 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.
zAt 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_pipelineptNtfZ transformersTFr z2Pipeline cannot infer suitable model classes from z.h5TZfrom_tfz}Model might be a TensorFlow model (ending with `.h5`) but TensorFlow is not available. Trying to load the model with PyTorch.z.binZfrom_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: .> r[ N> r\ N)r r RuntimeErrorr5 strgetr r Z
architectures importlib
import_modulerR appendtupler# r$ copyendswithloggerwarningfrom_pretrainedhasattrr^ OSError __class____name__
startswith)modelrV rW rX rY model_kwargsZ class_tupleZlook_ptZlook_tfclasses architectureZtransformers_module_classZ model_classkwargsr& r& r' infer_framework_load_model sb !
rw )rW rX rY c K sD t | tr"tj| 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 )rW rZ rX rY )r5 ra r rk rV rw )rq rW rX rY rr rV r& r& r' infer_framework_from_model s
rx )revisionc C s t jdt t r$t r$tdt| trt rLt rLtj | |d} nTt rjt rjt
j | |d} n6ytj | |d} W n" t k
r t
j | |d} Y nX | j j
jdrdnd}|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.zAt 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/.)ry r] r\ r[ )warningswarn
FutureWarningr r r` r5 ra r rk r rm rn ro rp )rq ry rY r& r& r'
get_framework, s"
r} )
targeted_taskrY task_optionsreturnc C s t rt rd}nt r&t r&d}| d }|rV||krHtd| || d }n d|krl| d d }ntd|dkrd}|| 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 rq zXThe task defaults can't be correctly selected. You probably meant "translation_XX_to_YY"N)r r r$ )r~ rY r defaultsZdefault_modelsr& r& r' get_default_modelN s r c s* e Zd ZdZeeed fdd Z ZS )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.
)rX rq reasonc s t j| || _|| _d S )N)super__init__rX rq )selfrX rq r )rn r& r' r s zPipelineException.__init__)ro
__module__ __qualname____doc__ra r
__classcell__r& r& )rn r' r x s r c @ s e Zd ZdZedd ZdS )ArgumentHandlerzQ
Base interface for handling arguments for each [`~pipelines.Pipeline`].
c O s
t d S )N)NotImplementedError)r argsrv r& r& r' __call__ s zArgumentHandler.__call__N)ro r r r r r r& r& r& r' r s r c @ s e Zd ZdZdddgZdee ee ee edddZe d d
Z
e e e e
e f d d d
Ze e e
e f edddZedeee ee ee d dddZdS )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 C s || _ || _|d k r |jdndg| _t| jdk| _| jrNdd | jD | _|d k rz| rztt| j rzt| j d|d k rtt| jst| j dd S )N, r c S s* g | ]"}d |kr t |jd n||fqS )=)rf split)r* cr& r& r' r- s z/PipelineDataFormat.__init__..z already exists on diskz doesnt exist on disk) r r r r r# is_multi_columnsr r rm )r r r r r r& r& r' r s zPipelineDataFormat.__init__c C s
t d S )N)r )r r& r& r' __iter__ s zPipelineDataFormat.__iter__)datac C s
t dS )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.
N)r )r r r& r& r' save s zPipelineDataFormat.save)r r c
C sJ t jj| j\}}t jjj|df}t|d}tj|| W dQ R X |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) ospathsplitextr extsepjoinopenr dump)r r r _Z binary_pathZf_outputr& r& r' save_binary s
z PipelineDataFormat.save_binary)formatr r r r c C s\ | dkrt ||||dS | dkr0t||||dS | dkrHt||||dS td| ddS )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.
r )r r r zUnknown reader z% (Available reader are json/csv/pipe)N)JsonPipelineDataFormatCsvPipelineDataFormatPipedPipelineDataFormatKeyError)r r r r r r& r& r' from_str s zPipelineDataFormat.from_strN)F)F)ro r r r ZSUPPORTED_FORMATSr ra boolr r r r dictr r r staticmethodr r& r& r& r' r s
" r c sR e Zd ZdZd ee ee ee d fdd
Zdd Zee dd d
Z
Z S ) r a
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`.
F)r r r c s t j||||d d S )N)r )r r )r r r r r )rn r& r' r s z CsvPipelineDataFormat.__init__c # sb t | jdL}tj|}x:|D ]2 | jr@ fdd| jD V q | jd V q W W d Q R X d S )Nrc s i | ]\}} | |qS r& r& )r* kr )rowr& r'
s z2CsvPipelineDataFormat.__iter__..r )r r r
DictReaderr r )r freaderr& )r r' r s
z CsvPipelineDataFormat.__iter__)r c C sR t | jd<}t|dkrDtj|t|d j }|j |j| W dQ R X dS )z
Save the provided data object with the representation for the current [`~pipelines.PipelineDataFormat`].
Args:
data (`List[dict]`): The data to store.
wr N) r r r# r
DictWriterlistrN writeheader writerows)r r r writerr& r& r' r " s
zCsvPipelineDataFormat.save)F) ro r r r r ra r r r r r r r& r& )rn r' r s
$ r c sN e Zd ZdZd ee ee ee d fdd
Zdd Zedd d
Z Z
S ) r a
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`.
F)r r r c s: t j||||d t|d}tj|| _W d Q R X d S )N)r r )r r r r load_entries)r r r r r r )rn r& r' r < s z JsonPipelineDataFormat.__init__c # sB x<| j D ]2 | jr* fdd| jD V q | jd V qW d S )Nc s i | ]\}} | |qS r& r& )r* r r )entryr& r' r K s z3JsonPipelineDataFormat.__iter__..r )r r r )r r& )r r' r H s z JsonPipelineDataFormat.__iter__)r c
C s( t | jd}tj|| W dQ R X dS )z|
Save the provided data object in a json file.
Args:
data (`dict`): The data to store.
r N)r r r r )r r r r& r& r' r O s zJsonPipelineDataFormat.save)F) ro r r r r ra r r r r r r& r& )rn r' r 0 s
$r c sJ e Zd ZdZdd ZedddZeeee f e d fdd Z
Z S )
r a
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 c sX xRt jD ]H}d|krJ|jd}| jr>dd t| j|D V qPt|V q|V qW d S )N c S s i | ]\\}}}||qS r& r& )r* rv r lr& r& r' r p s z4PipedPipelineDataFormat.__iter__..)sysstdinr r ziprf )r liner& r& r' r h s
z PipedPipelineDataFormat.__iter__)r c C s t | dS )z^
Print the data.
Args:
data (`dict`): The data to store.
N)print)r r r& r& r' r x s z PipedPipelineDataFormat.save)r r c s | j d krtdt j|S )NzWhen using piped input on pipeline outputting large object requires an output file path. Please provide such output path through --output argument.)r r r r )r r )rn r& r' r s
z#PipedPipelineDataFormat.save_binary) ro r r r r r r r r ra r r r& r& )rn r' r Z s r c @ s( e Zd ZdZedd Zedd ZdS )
_ScikitCompatzA
Interface layer for the Scikit and Keras compatibility.
c C s
t d S )N)r )r Xr& r& r' transform s z_ScikitCompat.transformc C s
t d S )N)r )r r r& r& r' predict s z_ScikitCompat.predictN)ro r r r r r r r& r& r& r' r s r a
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.
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.
)PipelineChunkIteratorPipelineDatasetPipelineIteratorPipelinePackIteratorc @ sB e Zd ZdZdZd6ed7 ee ee ee ee
e
e e e
d d d
Ze
d d d
Zdd Zdd Zedd Zdd Zdd Zeee
ef dddZedd Zeee e e
e f d d d Z ee e
e f e e d d!d"Z ee e ed#d$d%Z!d&d' Z"d(d) Z#e e d*d+d,Z$ddd*d-d.Z%d/d0 Z&d1d2 Z'd3d4 Z(dS )8Pipelinea
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.
Nr r Fr" r! ) rq rS rT modelcardrY rX args_parserdevice
binary_outputc
K s |d krt ||jd\}}|| _|| _|| _|| _|| _|| _|dkrJ|ntj |dk rZdnd| | _ | | _
| jdkr| j j dkr| jj | j | _| jjj
} | d k r|| kr| jjj| j| d| _|
jdd | _|
jd d | _| jf |
\| _| _| _d S )
N)rV r\ r cpuzcuda:r[ cudar> num_workers)rw rV rX rq rS rT r rY r6 r r typetotask_specific_paramsupdaterb
call_countpop _batch_size _num_workers_sanitize_parameters_preprocess_params_forward_params_postprocess_params) r rq rS rT r rY rX r r r rv r r& r& r' r s& *
zPipeline.__init__)save_directoryc C s t jj|r"tjd| d dS t j|dd | jj| | jdk rR| jj| | j dk rh| j j| | j
dk r~| j
j| dS )z
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.
zProvided path (z#) should be a directory, not a fileNT)exist_ok) r r isfileri errormakedirsrq save_pretrainedrS rT r )r r r& r& r' r s
zPipeline.save_pretrainedc C s
| |dS )zn
Scikit / Keras interface to transformers' pipelines. This method will forward to __call__().
)r r& )r r r& r& r' r s zPipeline.transformc C s
| |dS )zn
Scikit / Keras interface to transformers' pipelines. This method will forward to __call__().
)r r& )r r r& r& r' r s zPipeline.predictc c sb | j dkr>tj| jdkr dn
d| j dV W dQ R X n | jjdkrXtjj| j dV dS )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\ r z/CPU:0z /device:GPU:Nr r4 )rY r\ r r r6 r Z
set_device)r r& r& r' device_placement% s
" zPipeline.device_placementc K s | j || 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 )r inputsr& r& r' ensure_tensor_on_device? s z Pipeline.ensure_tensor_on_devicec s t |tr&t fdd|j D S t |trH fdd|j D S t |trnt fdd|j D S t |tr fdd|D S t |trt fdd|D S t |tjr|j S |S d S )Nc s i | ]\}}j | |qS r& )r )r* namer@ )r r r& r' r P s z5Pipeline._ensure_tensor_on_device..c s i | ]\}}j | |qS r& )r )r* r r@ )r r r& r' r S s c s i | ]\}}j | |qS r& )r )r* r r@ )r r r& r' r U s c s g | ]}j | qS r& )r )r* r+ )r r r& r' r- W s z5Pipeline._ensure_tensor_on_device..c s g | ]}j | qS r& )r )r* r+ )r r r& r' r- Y s )
r5 r r% r r r rf r6 r7 r )r r r r& )r r r' r M s
z!Pipeline._ensure_tensor_on_device)supported_modelsc C s t |tsTg }x@|j D ]4\}}t |tr@|jdd |D q|j|j qW |}| jjj|krt j
d| jjj d| j d| d dS )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.
c S s g | ]
}|j qS r& )ro )r* _modelr& r& r' r- l s z-Pipeline.check_model_type..z The model 'z' is not supported for z. Supported models are r_ N) r5 r r% rf extendre ro rq rn ri r rX )r r Zsupported_models_namesrV rq r& r& r' check_model_type_ s
zPipeline.check_model_typec K s t ddS )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 implementedN)r )r Zpipeline_parametersr& r& r' r u s z Pipeline._sanitize_parameters)input_preprocess_parametersr c K s t ddS )z
Preprocess will take the `input_` of a specific pipeline and return a dictionnary of everything necessary for
`_forward` to run properly. It should contain at least one tensor, but might have arbitrary other items.
zpreprocess not implementedN)r )r r r r& r& r'
preprocess s zPipeline.preprocess)
input_tensorsforward_parametersr c K s t ddS )a
_forward will receive the prepared dictionnary 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 implementedN)r )r r r r& r& r' _forward s zPipeline._forward)
model_outputspostprocess_parametersr c K s t ddS )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 implementedN)r )r r r r& r& r' postprocess s zPipeline.postprocessc C s& t jtjt jdkr tjntj}|S )Nz1.9.0)r parser6 __version__Zinference_modeZno_grad)r inference_contextr& r& r' get_inference_context s "z Pipeline.get_inference_contextc K s | j | jdkr,d|d< | j|f|}nj| jdkr| j }| 8 | j|| jd}| j|f|}| j|tjdd}W d Q R X ntd| j dW d Q R X |S ) Nr\ FZtrainingr[ )r r z
Framework z is not supported)r rY r r r r r6 r$ )r model_inputsforward_paramsr r r& r& r' forward s
zPipeline.forward)r r> c C s t |tjjr t|| j|}n$|dkr4tjd d}t|| j|}dt j
kr`tj d dt j
d< |dkrlt n t
| j| 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_PARALLELISMzNDisabling tokenizer parallelism, we're using DataLoader multithreading alreadyfalse)r r>
collate_fn)loader_batch_size)r5 collectionsabcSizedr r ri rj r r environinfor( rU rS rT r r r ) r r r r> preprocess_paramsr postprocess_paramsdatasetr
dataloadermodel_iteratorfinal_iteratorr& r& r' get_iterator s
zPipeline.get_iteratorc O s |rt jd| |d kr2| jd kr,d}n| j}|d krP| jd krJd}n| j}| jf |\}}}| j|}| j|}| j|}| jd7 _| jdkr| j dkr| j
j dkrt j
dt td k ot|t} t|tj}
t|t} | p|
p| } | j dko| p|
p| }
| rN|
r<| j||||||}dd |D }|S | j||||S n@|
rh| j||||||S | r~| j||||S | j||||S d S )
NzIgnoring args : r r
r[ r zlYou seem to be using the pipelines sequentially on GPU. In order to maximize efficiency please use a datasetc S s g | ]}|qS r& r& )r* outputr& r& r' r- s z%Pipeline.__call__..)ri rj r r r r r r r rY r r rz r{ UserWarningr r5 types
GeneratorTyper r run_multiiterate
run_single)r r r r> r rv r r r Z
is_datasetZ is_generatorZis_list is_iterableZcan_use_iteratorr outputsr& r& r' r sJ
zPipeline.__call__c s fdd|D S )Nc s g | ]}j | qS r& )r )r* r+ )r r r r r& r' r- s z&Pipeline.run_multi..r& )r r r r r r& )r r r r r' r s zPipeline.run_multic C s. | j |f|}| j|f|}| j|f|}|S )N)r r r )r r r r r r r r r& r& r' r s zPipeline.run_singlec c s$ x |D ]}| j ||||V qW d S )N)r )r r r r r r r& r& r' r
s
zPipeline.iterater4 )NNNNr Nr4 F)r" r! ))ro r r r Zdefault_input_namesr r r r r ra r intr r r r r r r r r r r r r r r r
r r r r r r r r r r r r r& r& r& r' r s> 4
8r c @ s$ e Zd Zdd ZeedddZdS )
ChunkPipelinec C sF g }x.| j |f|D ] }| j|f|}|j| qW | j|f|}|S )N)r r re r ) r r r r r Z all_outputsr r r r& r& r' r s zChunkPipeline.run_single)r r> c C s dt jkr tjd dt jd< |dkr4tjd d}t|| j|}|dkrNtn t| j | j
}t ||||d} t | | j
||d}
t|
| j|} | S )Nr zNDisabling tokenizer parallelism, we're using DataLoader multithreading alreadyr r zFor ChunkPipeline using num_workers>0 is likely to result in errors since everything is iterable, setting `num_workers=1` to guarantee correctness.)r r> r )r
)r r ri r rj r r r( rU rS rT r r r r r ) r r r r> r r r r r r r r r& r& r' r s
zChunkPipeline.get_iteratorN)ro r r r r! r r& r& r& r' r" s r" )NNN)NNN)N)Wr r rc r r r r r rz r r r r
contextlibr os.pathr r typingr r r
r r r
r packagingr Zfeature_extraction_utilsr r r Z models.auto.configuration_autor Ztokenization_utilsr utilsr r r r r r Z
tensorflowr\ Z models.auto.modeling_tf_autor r6 Ztorch.utils.datar r Zmodels.auto.modeling_autor Zpt_utilsr Zmodeling_tf_utilsr! Zmodeling_utilsr"
get_loggerro ri r( rB rU ra r rw rx r} r Exceptionr r r r r r r ZPIPELINE_INIT_ARGSZ transformers.pipelines.pt_utilsr r r r r r" r& r& r& r' sx $
"= .^ ,#" *
q,*1/ P