a
dG @ sr d Z ddlmZmZmZmZ ddlZddlm Z m
Z
ddl m Z m
Z
mZmZmZmZ eeZG dd de
ZdS ) z[
Sequence feature extraction class for common feature extractors to preprocess sequences.
)DictListOptionalUnionN ) BatchFeatureFeatureExtractionMixin)PaddingStrategy
TensorType is_tf_tensoris_torch_tensorloggingto_numpyc s e Zd ZdZeeed fdd Zdeee e e
e ef e
e e e f e e
e ef f ee e e
f ee e ee ee eee ef edd d
Zde
jddfee
e ejf ef ee e
ee ee ed d d
Zdee
e ejf ef ee ee ee dddZdddZ ZS )SequenceFeatureExtractora
This is a general feature extraction class for speech recognition.
Args:
feature_size (`int`):
The feature dimension of the extracted features.
sampling_rate (`int`):
The sampling rate at which the audio files should be digitalized expressed in hertz (Hz).
padding_value (`float`):
The value that is used to fill the padding values / vectors.
) feature_size
sampling_rate
padding_valuec sD || _ || _|| _|dd| _|dd| _t jf i | d S )N padding_siderightreturn_attention_maskT)r r r popr r super__init__)selfr r r kwargs __class__ w/var/www/html/stable-diffusion-webui/venv/lib/python3.9/site-packages/transformers/feature_extraction_sequence_utils.pyr * s z!SequenceFeatureExtractor.__init__TNF)processed_featurespadding
max_length
truncationpad_to_multiple_ofr return_tensorsreturnc s t ttfr:t d ttfr:fddd D jd vrjtdjd dt jd }|dur|nj}t |dkr|rg d< S |d } t | ttfrd}
t ||
dkr|
d7 }
q|
t |k r||
d } |du rTt
| r d }nHt | r d
}n8t | t t
tttjfr:d }ntd | d
t| d D ]>\} } t | d t t
frt| | < ndd | D | < q\j||d}
jd }t | t fdd D stdg }t D ]8fdd D }j||||d}|| q|
tjkrRtfdd|D }tj }
i }t D ]rj | ||
||d}| D ]J\} } | |vrg || < | j t tj u r| tj!} || | qq^t||dS )a
Pad input values / input vectors or a batch of input values / input vectors up to predefined length or to the
max sequence length in the batch.
Padding side (left/right) padding values are defined at the feature extractor level (with `self.padding_side`,
`self.padding_value`)
If the `processed_features` passed are dictionary of numpy arrays, PyTorch tensors or TensorFlow tensors, the
result will use the same type unless you provide a different tensor type with `return_tensors`. In the case of
PyTorch tensors, you will lose the specific device of your tensors however.
Args:
processed_features ([`BatchFeature`], list of [`BatchFeature`], `Dict[str, List[float]]`, `Dict[str, List[List[float]]` or `List[Dict[str, List[float]]]`):
Processed inputs. Can represent one input ([`BatchFeature`] or `Dict[str, List[float]]`) or a batch of
input values / vectors (list of [`BatchFeature`], *Dict[str, List[List[float]]]* or *List[Dict[str,
List[float]]]*) so you can use this method during preprocessing as well as in a PyTorch Dataloader
collate function.
Instead of `List[float]` you can have tensors (numpy arrays, PyTorch tensors or TensorFlow tensors),
see the note above for the return type.
padding (`bool`, `str` or [`~utils.PaddingStrategy`], *optional*, defaults to `True`):
Select a strategy to pad the returned sequences (according to the model's padding side and padding
index) among:
- `True` or `'longest'`: Pad to the longest sequence in the batch (or no padding if only a single
sequence if provided).
- `'max_length'`: Pad to a maximum length specified with the argument `max_length` or to the maximum
acceptable input length for the model if that argument is not provided.
- `False` or `'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of different
lengths).
max_length (`int`, *optional*):
Maximum length of the returned list and optionally padding length (see above).
truncation (`bool`):
Activates truncation to cut input sequences longer than `max_length` to `max_length`.
pad_to_multiple_of (`int`, *optional*):
If set will pad the sequence to a multiple of the provided value.
This is especially useful to enable the use of Tensor Cores on NVIDIA hardware with compute capability
`>= 7.5` (Volta), or on TPUs which benefit from having sequence lengths be a multiple of 128.
return_attention_mask (`bool`, *optional*):
Whether to return the attention mask. If left to the default, will return the attention mask according
to the specific feature_extractor's default.
[What are attention masks?](../glossary#attention-mask)
return_tensors (`str` or [`~utils.TensorType`], *optional*):
If set, will return tensors instead of list of python integers. Acceptable values are:
- `'tf'`: Return TensorFlow `tf.constant` objects.
- `'pt'`: Return PyTorch `torch.Tensor` objects.
- `'np'`: Return Numpy `np.ndarray` objects.
r c s i | ] fd dD qS )c s g | ] }| qS r r ).0Zexamplekeyr r
z;SequenceFeatureExtractor.pad...r )r& )r r' r
~ s z0SequenceFeatureExtractor.pad..zYou should supply an instance of `transformers.BatchFeature` or list of `transformers.BatchFeature` to this method that includes z, but you provided Nattention_maskr tfptnpztype of z
unknown: zA. Should be one of a python, numpy, pytorch or tensorflow object.c S s g | ] }t |qS r )r r& vr r r r) r* z0SequenceFeatureExtractor.pad..)r r! c 3 s | ]}t | kV qd S )N)lenr0 )
batch_sizer r r* z/SequenceFeatureExtractor.pad..zLSome items in the output dictionary have a different batch size than others.c s i | ]\}}|| qS r r )r& kr1 )ir r r+ r* )r! r# r" c 3 s | ]}t | jd V qdS )r N)r2 model_input_names)r& Z input_slice)r r r r4 r* )r! padding_strategyr# r )Z tensor_type)"
isinstancelisttupledictr keysr7
ValueErrorr r2 r r intfloatr/ ndarraytypeitemsr _get_padding_strategiesallvaluesrange _truncateappendr LONGESTmax
MAX_LENGTH_paddtypefloat64Zastypefloat32)r r r r! r" r# r r$ required_inputZ
first_elementindexr( valuer8 Ztruncated_inputsinputsZ inputs_sliceZ
batch_outputsoutputsr )r3 r6 r r r pad4 s I
z SequenceFeatureExtractor.pad)r r! r8 r# r r% c
C s| || j d }|tjkr t|}|durL|durL|| dkrL|| d | }|tjko`t||k }|rd|vrtjt|tjd|d< |rx|t| }| jdkr|rt |d d|f|d< | j
dkrd|fdfnd|f} tj || d| j d || j d < n|| jd
krf|r&t |d |df|d< | j
dkr>|dfdfn|df} tj || d| j d || j d < nt d t
| j |S ) a
Pad inputs (on left/right and up to predefined length or max length in the batch)
Args:
processed_features (`Union[Dict[str, np.ndarray], BatchFeature]`):
Dictionary of input values (`np.ndarray[float]`) / input vectors (`List[np.ndarray[float]]`) or batch
of inputs values (`List[np.ndarray[int]]`) / input vectors (`List[np.ndarray[int]]`)
max_length (`int`, *optional*):
Maximum length of the returned list and optionally padding length (see below)
padding_strategy (`PaddingStrategy`, *optional*, default to `PaddingStrategy.DO_NOT_PAD`):
PaddingStrategy to use for padding.
- PaddingStrategy.LONGEST Pad to the longest sequence in the batch
- PaddingStrategy.MAX_LENGTH: Pad to the max length (default)
- PaddingStrategy.DO_NOT_PAD: Do not pad
The feature_extractor padding sides are defined in self.padding_side:
- 'left': pads on the left of the sequences
- 'right': pads on the right of the sequences
pad_to_multiple_of (`int`, *optional*):
Integer if set will pad the sequence to a multiple of the provided value. This is especially useful to
enable the use of Tensor Core on NVIDIA hardware with compute capability `>= 7.5` (Volta), or on TPUs
which benefit from having sequence lengths be a multiple of 128.
return_attention_mask (`bool`, *optional*):
Set to False to avoid returning attention mask (default: set to model specifics)
r Nr r, )rN r )r r Zconstant)Zconstant_valuesleftzInvalid padding strategy:)r7 r rJ r2
DO_NOT_PADr/ Zonesint32r rV r r r> str)
r r r! r8 r# r rQ Zneeds_to_be_padded
differenceZ
padding_shaper r r rM s< "
z SequenceFeatureExtractor._pad)r r! r# r" c C s |s|S |r |du r t d|| jd }|durV|durV|| dkrV|| d | }t||k}|r|| jd d| || jd < d|v r|d d| |d< |S )a
Truncate inputs to predefined length or max length in the batch
Args:
processed_features(`Union[Dict[str, np.ndarray], BatchFeature]`):
Dictionary of input values (`np.ndarray[float]`) / input vectors (`List[np.ndarray[float]]`) or batch
of inputs values (`List[np.ndarray[int]]`) / input vectors (`List[np.ndarray[int]]`)
max_length (`int`, *optional*):
maximum length of the returned list and optionally padding length (see below)
pad_to_multiple_of (`int`, *optional*) :
Integer if set will pad the sequence to a multiple of the provided value. This is especially useful to
enable the use of Tensor Core on NVIDIA hardware with compute capability `>= 7.5` (Volta), or on TPUs
which benefit from having sequence lengths be a multiple of 128.
truncation (`bool`, *optional*):
Activates truncation to cut input sequences longer than `max_length` to `max_length`.
NzKWhen setting ``truncation=True``, make sure that ``max_length`` is defined.r r r, )r> r7 r2 )r r r! r# r" rQ Zneeds_to_be_truncatedr r r rH * s z"SequenceFeatureExtractor._truncatec C s |dur<|du rt j}qBt|t s,t |}qBt|t rB|}nt j}|du rf|t jkrftdt j d|t jkr| jdu rtd|S )z3
Find the correct padding strategy
FTNzWhen setting ``padding=z(``, make sure that max_length is definedzAsking to pad but the feature_extractor does not have a padding value. Please select a value to use as `padding_value`. For example: `feature_extractor.padding_value = 0.0`.)r rJ r9 rX rL r> r )r r r! r8 r r r rD U s$
z0SequenceFeatureExtractor._get_padding_strategies)TNFNNN)NNN)FN)__name__
__module__ __qualname____doc__r? r@ r r r r r rZ boolr r r
rV rX r/ rA r< rM rH rD
__classcell__r r r r r s`
2 K +r )r_ typingr r r r numpyr/ Zfeature_extraction_utilsr r utilsr r
r r r
r Z
get_loggerr\ loggerr r r r r s