+
jK R t ^ RIt^RIHtHt ^RIHtHt ^RI H
t
H t H t H
t
Ht ]
P ! ]4 t ! R R]4 tR# )zZ
Sequence feature extraction class for common feature extractors to preprocess sequences.
N)is_valid_audio
load_audio) BatchFeatureFeatureExtractionMixin)PaddingStrategy
TensorTypeis_torch_tensorloggingto_numpyc a a ] tR t^ t oRtV3R lV 3R lltRV3R lR lltR]P RR3V3R lR llt RV3R lR
llt
RR lt RV3R lR
llt Rt
VtV ;t# )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.
c , < V ^8 d QhRS[ RS[ RS[/# ) feature_size
sampling_rate
padding_value)intfloat)format
__classdict__s "o/home/luca/screen-checking/.venv/lib/python3.14/site-packages/transformers/feature_extraction_sequence_utils.py __annotate__%SequenceFeatureExtractor.__annotate__) s" # #S # #U # c < Wn W n W0n VP R R4 V n VP RR4 V n \ SV ` ! R/ VB R# ) padding_siderightreturn_attention_maskTN )r r r popr r super__init__)selfr r r kwargs __class__s &&&&,r r! !SequenceFeatureExtractor.__init__) sL ( * * "JJ~w ?%+ZZ0G%N"
"6"r Nc d < V ^8 d QhRS[ S[S[ , , S[S[S[ 3, , S[S[S[S[ , 3, , S[S[S[S[ 3, , , RS[S[, S[, RS[R, RS[RS[R, RS[R, RS[S[, R, R S[ /# )
r processed_featurespadding
max_lengthN
truncationpad_to_multiple_ofr return_tensorsreturn)r listdictstrboolr r r )r r s "r r r 3 s kG kG (
|
sL
! " sD &&
' ( tC %&
' (kG o-kG $JkG kG $JkG $d{kG j(4/kG
kGr c
0 a a \ V\ \ 34 ' db \ V^ , \ \ 34 ' d? V^ , P 4 UU u/ uF qV U u. uF qV, NK
up bK ppp S P ^ , V9 d: \ RS P ^ , R\ VP 4 4 24 hVS P ^ , , p
Ve TM S P p\ V
4 ^ 8X d V' d . VR& V# V
^ , p \ V \ \ 34 ' dC ^ p \ W, 4 ^ 8X d V ^,
p K! V \ V
4 8 d W, ^ , p Vfh \ V 4 ' d RpMS\ V \ \ \ \ \ P 34 ' d RpM\ RV R\ V 4 R24 hVP! 4 Fv w r\ V
^ , \ \ 34 ' d \# V
4 W& K7 \ V
\ P 4 ' d KY V
Uu. uF p\# V4 NK upW& Kx S P% W#R 7 pVS P ^ , , p
\ V
4 o\& ;QJ d- V3R
lVP) 4 4 F ' d K R M" R M ! V3R
lVP) 4 4 4 ' g \ R
4 h. p\+ S4 FU pVP! 4 UUu/ uF w ppVVV, bK pppS P- VVVVR7 pVP/ V4 KW V\0 P2 8X d& \5 V 3R lV 4 4 p\0 P6 p/ p\+ S4 F pS P9 VV, VVVVR7 pVP! 4 Fz w rVV9 d . VV& V
P: \ P: ! \ P< 4 J d V
P? \ P@ 4 p
VV, P/ V
4 K| K \ VVR7 # u up i u up pi u upi u uppi )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 or PyTorch 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 or PyTorch 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:
- `'pt'`: Return PyTorch `torch.Tensor` objects.
- `'np'`: Return Numpy `np.ndarray` objects.
zYou should supply an instance of `transformers.BatchFeature` or list of `transformers.BatchFeature` to this method that includes z, but you provided attention_maskptnpztype of z
unknown: z6. Should be one of a python, numpy, or pytorch object.)r( r) c 3 @ <" T F p\ V4 S8H x K R # 5iN)len).0v
batch_sizes & r /SequenceFeatureExtractor.pad.. s M1LA3q6Z'1Ls FTzLSome items in the output dictionary have a different batch size than others.)r) r+ r* c 3 j <" T F( p\ VSP ^ , , 4 x K* R# 5i) N)r8 model_input_names)r9 input_slicer" s & r r< r= s+ m\l[ST-C-CA-F!G H H\ls 03)r) padding_strategyr+ r ) tensor_type)!
isinstancer. tupler/ r keysr@
ValueErrorr r8 r r r r5 ndarraytypeitemsr
_get_padding_strategiesallvaluesrange _truncateappendr LONGESTmax
MAX_LENGTH_paddtypefloat64astypefloat32)r" r' r( r) r* r+ r r, keyexamplerequired_input
first_elementindexvaluer: rB truncated_inputsikinputs inputs_slice
batch_outputsoutputsr; s f&&&&&&& @r pad SequenceFeatureExtractor.pad3 s! L (4- 8 8ZHZ[\H]`dfr_s=t=t RddeQfQkQkQm"Qm#2DE2Dwcll2DEEQm
"
! !! $,> > 1151G1G1J0K L+002346
,D,B,B1,EF%:%F !DLfLf ~ ! #$79"#34% % 'q)
mdE] 3 3En+,1
s>** . 5a 8
! }--!%MCeRZZ+PQQ!% }oZ]8K7L MK K
-224JC%(S%L11*25/"' rzz22 AF*F18A;*F"' 5 777_+D,B,B1,EF (
sM1C1J1J1LMsssM1C1J1J1LMMM kl l z"A*<*B*B*DE*D$!Qa1g*DFE >>%#5% * L
# #L 1 # 6 6 6 m\l mmJ . 9 9
z"Aii #%!1#5&; G &mmo
m+)+M#&;;"((2::"66 !LL 4E c"))%0 . #" M~FFE F"j +G Fs$ R%R6RR
9RRc < V ^8 d QhRS[ S[S[P 3, S[, RS[R, RS[RS[R, RS[R, RS[ /# )r r' r) NrB r+ r r- )r/ r0 r5 rH r r r r1 )r r s "r r r sm F" F" bjj 1L @F" $JF" * F"
$J F" $d{
F"
F"r c ^ WP ^ , , pV\ P 8X d \ V4 pVe( Ve$ W$, ^ 8w d W$, ^, V, pV\ P 8g ;' d \ V4 V8 pV' d: RV9 d3 \
P ! \ V4 \
P R7 VR& V' EdV V\ V4 ,
pV P R8X d V' d$ \
P ! VR, ^ V34 VR& V P ^8 d ^ V3R3M^ V3p \
P ! WiRV P R7 WP ^ , & V# V P R8X d V' d$ \
P ! VR, V^ 34 VR& V P ^8 d V^ 3R3MV^ 3p \
P ! WiRV P R7 WP ^ , & V# \ R\ V P 4 , 4 hV# ) 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)
r3 )rU r constant)constant_valuesleftzInvalid padding strategy:)r? r? )r@ r rQ r8
DO_NOT_PADr5 onesint32r rf r r rG r0 )
r" r' r) rB r+ r r[ needs_to_be_padded
difference
padding_shapes
&&&&&& r rT SequenceFeatureExtractor._pad s
D ,,B,B1,EF 6 6 6 ^,J !&8&D*JimnJn%;q@DVVJ - 1K1K K p pPSTbPcfpPp %5=O%O35773~;NVXV^V^3_ / 0 #c.&99J G+(;=66*+;B=N=NQR=R!Z & 9YZ\fXg
@B":tOaOaA"#9#9!#<= "! ""f,(;=66*+;B=N=NQR=R*a & 9YcefXg
@B":tOaOaA"#9#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.r3 )rG r@ r8 )r" r' r) r+ r* r[ needs_to_be_truncateds &&&&& r rO "SequenceFeatureExtractor._truncate( s . % %
J . jk k+,B,B1,EF !&8&D*JimnJn%;q@DVVJ #N 3j @ r s> 3 J R R
H %gw 5 gwr