a
haG @ sj d Z ddlmZmZ ddlZddlmZmZ ddl m
Z
m Z m Z m
Z
mZmZ eeZG dd deZdS ) zZ
Sequence feature extraction class for common feature extractors to preprocess sequences.
)OptionalUnionN ) 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 e
d 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__ j/var/www/html/assistant/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 ttfr6t d ttfr6fddd D jd vrftdjd dt jd }|dur|nj}t |dkr|rg d< S |d } t | ttfrd}
t ||
dkr|
d7 }
q|
t |k r||
d } |du rPt
| rd }nHt | rd
}n8t | t t
tttjfr6d }ntd | d
t| d D ]>\} } t | d t t
frt| | < ndd | D | < qXj||d}
jd }t | t fdd D stdg }t D ]8fdd D }j||||d}|| q|
tjkrNtfdd|D }tj }
i }t D ]rj | ||
||d}| D ]J\} } | |vrg || < | j t tj u r| tj!} || | q~qZt||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)lenr. )
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$ kr/ )ir r r) r( )r r! r c 3 s | ]}t | jd V qdS )r N)r0 model_input_names)r$ Z input_slice)r r r r2 r( )r padding_strategyr! r )Z tensor_type)"
isinstancelisttupledictr r5
ValueErrorkeysr r0 r r
intfloatr- ndarraytypeitemsr _get_padding_strategiesallvaluesrange _truncateappendr LONGESTmax
MAX_LENGTH_paddtypeZfloat64ZastypeZfloat32)r r r r r r! r r" required_inputZ
first_elementindexr& valuer6 Ztruncated_inputsinputsZ inputs_sliceZ
batch_outputsoutputsr )r1 r4 r r r pad4 s I
z SequenceFeatureExtractor.pad)r r r6 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* )rL r )r r Zconstant)Zconstant_valuesleftzInvalid padding strategy:)r5 r rH r0
DO_NOT_PADr- ZonesZint32r rR r r r; str)
r r r r6 r! r rM Zneeds_to_be_padded
differenceZ
padding_shaper r r rK 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; r5 r0 )r r r r! r rM Zneeds_to_be_truncatedr r r rF * 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 rH r7 rT rJ r; r )r r r r6 r r r rB U s$
z0SequenceFeatureExtractor._get_padding_strategies)TNFNNN)NNN)FN)__name__
__module__ __qualname____doc__r= r> r r r r8 r: rU boolr r r rR rT r- r? rK rF rB
__classcell__r r r r r
s`
2 K +r
)rZ typingr r numpyr- Zfeature_extraction_utilsr r utilsr r r r
r r Z
get_loggerrW loggerr
r r r r s