gG d Z ddlmZmZmZmZ ddlZddlm Z m
Z
ddl m Z m
Z
mZmZmZmZ ej e Z G d de
ZdS ) zZ
Sequence feature extraction class for common feature extractors to preprocess sequences.
)DictListOptionalUnionN ) BatchFeatureFeatureExtractionMixin)PaddingStrategy
TensorType is_tf_tensoris_torch_tensorloggingto_numpyc e Zd ZdZdededef fd Z dd eee e e
e ef e
e e e f e e
e ef f d
ee e e
f d ee d e d
ee dee deee ef defdZde
j ddfd ee
e ej f ef d ee de
d
ee dee def dZ dd ee
e ej f ef d ee d
ee d ee fdZddZ xZS )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 || _ || _ || _ | dd | _ | dd | _ t
j di | d S )N padding_siderightreturn_attention_maskT )r r r popr r super__init__)selfr r r kwargs __class__s j/var/www/html/ai-engine/env/lib/python3.11/site-packages/transformers/feature_extraction_sequence_utils.pyr z!SequenceFeatureExtractor.__init__+ sk ( * * "JJ~w ? ?%+ZZ0G%N%N"""6""""" TNFprocessed_featurespadding
max_length
truncationpad_to_multiple_ofr return_tensorsreturnc B t t t f rHt d t t f r&fdd D j d vr?t d j d dt j d }||n j }t | dk r |rg d< S |d } t | t t f rZd}
t ||
dk r |
dz
}
t ||
dk |
t | k r||
d } |}t | rd}nkt | rd }nYt | t t t t t j f rd
}n#t d | d t! | d
D ]I\ } } t | d t t f rt% | | < :d | D | < J || }
j d }t | t) fd D st d g }t- D ]Pfd D } |||| }| | Q|
t2 j k r't7 fd|D }t2 j }
i }t- D ] | ||
|| }| D ]m\ } } | |vrg || < | j t j t j u r | t j! } || | nt || S )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 0 i | ]fd D S )c g | ]
}| S r r ).0examplekeys r
z;SequenceFeatureExtractor.pad... s EEEwgclEEEr! r )r, r. r" s @r
z0SequenceFeatureExtractor.pad.. s? " " "JMEEEE2DEEE" " "r! 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 , g | ]}t | S r )r )r, vs r r/ z0SequenceFeatureExtractor.pad.. s *F*F*F18A;;*F*F*Fr! )r# r$ c 3 > K | ]}t | k V d S )N)len)r, r6
batch_sizes r z/SequenceFeatureExtractor.pad.. s. MMA3q66Z'MMMMMMr! zLSome items in the output dictionary have a different batch size than others.c ( i | ]\ }}|| S r r )r, kr6 is r r0 z0SequenceFeatureExtractor.pad.. s# EEE$!Qa1EEEr! )r$ r& r% c 3 X K | ]$}t |j d V %dS )r N)r8 model_input_names)r, input_slicer s r r: z/SequenceFeatureExtractor.pad.. s8 m m[ST-CA-F!G H H m m m m m mr! )r$ padding_strategyr& r ) tensor_type)"
isinstancelisttupledictr keysr?
ValueErrorr r8 r r
intfloatr4 ndarraytypeitemsr _get_padding_strategiesallvaluesrange _truncateappendr
LONGESTmax
MAX_LENGTH_paddtypefloat64astypefloat32)r r" r# r$ r% r& r r' required_input
first_elementindexr. valuerA truncated_inputsinputs inputs_slice
batch_outputsoutputsr9 r= s `` @@r padz SequenceFeatureExtractor.pad5 s R (4- 8 8 ZHZ[\H]`dfr_s=t=t " " " "QcdeQfQkQkQmQm" " "
!! $,> > > 6151G1J6 6+0022336 6
,D,B1,EF%:%F ! !DLf ~ ! # #$
:79"#34% % 'q)
mdE] 3 3 9EnU+,,11
nU+,,11s>**** .u 5a 8
!M**
!% //
!%MCeRZ+PQQ
!% V} V V]8K8K V V V
-2244 G GJC%(S%L11
G*25//"3''*F*F*F*F*F"3'' 77T^7__+D,B1,EF ((
MMMM1C1J1J1L1LMMMMM m kll l z"" 2 2AEEEE*<*B*B*D*DEEEF >>%#5% * L
# #L 1 1 1 1 6 6 6 m m m m\l m m mmmJ . 9
z"" 1 1Aii #%!1#5&; G &mmoo
1
1
Um++)+M#&;"(2:"6"666 !LL 4 4E c"))%0000
1 M~FFFFr! rA c v || j d }|t j k rt | }||||z dk r ||z dz |z }|t j k ot | |k }|r4d|vr0t j t | t
j |d< |r|t | z
}| j dk rc|r t j |d d|f |d< | j
dk rd|fdfnd|f} t j || d| j || j d < n| j d
k rc|r t j |d |df |d< | j
dk r|dfdfn|df} t j || d| j || j d < n$t d t | j z |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 r1 )rX r )r r constant)constant_valuesleftzInvalid padding strategy:)r? r
rT r8
DO_NOT_PADr4 onesint32r re r r rH str)
r r" r$ rA r& r r\ needs_to_be_padded
difference
padding_shapes
r rW z SequenceFeatureExtractor._pad sD D ,D,B1,EF 6 6 6 ^,,J !&8&D*WiJimnJnJn%);;q@DVVJ - 1K K pPSTbPcPcfpPp `%5=O%O%O3573~;N;NVXV^3_3_3_ / 0 W#c.&9&99J G++( ;=6*+;B=NQR=R=R!Z & 9 9YZ\fXg
@B"M:tOaA A A"4#9!#<== "f,,( ;=6*+;B=NQR=R=R*a & 9 9YcefXg
@B"M:tOaA A A"4#9!#<== !!= 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 r1 )rH r? r8 )r r" r$ r& r% r\ needs_to_be_truncateds r rR z"SequenceFeatureExtractor._truncate+ s . l% %
lJ . jkk k+D,B1,EF !&8&D*WiJimnJnJn%);;q@DVVJ #N 3 3j @ ir s / . . . . . . . . . . . J J J J J J J J ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` `
H % %V V V V V 5 V V V V V r!