tjK d Z ddlZddlmZmZ ddlmZmZ ddl m
Z
m Z m Z m
Z
mZ e
j e Z G d de ZdS ) zZ
Sequence feature extraction class for common feature extractors to preprocess sequences.
N )is_valid_audio
load_audio) BatchFeatureFeatureExtractionMixin)PaddingStrategy
TensorTypeis_torch_tensorloggingto_numpyc e Zd ZdZdededef fd Z dd eee z e e
ef z e e
ee f z ee e
ef z d
e e
z e z d edz d e d
edz de dz de
e
z dz defdZde j ddfd e e
ej f ez d edz de d
edz de dz de f dZ dd e e
ej f ez d edz d
edz d e dz fdZddZdde
ee
z eee
z dedz fdZ 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 l/var/www/html/CA-Chatbot/venv/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 R 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 } |kt | rd}nYt | t t t t t j f rd }n#t d
| d t | d D ]c\ } } t | d t t f rt# | | < :t | t j sd
| D | < d || }
j d }t | t' fd D st d g }t+ D ]Pfd D } |||| }| | Q|
t0 j k r't5 fd|D }t0 j }
i }t+ D ] | ||
|| }| D ]m\ } } | |vrg || < | j t j t j u r | t j } || | nt || S )a2
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.
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 ptnpztype of z
unknown: z6. Should be one of a python, numpy, or pytorch 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) r2
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) kr2 is r r- z0SequenceFeatureExtractor.pad.. s# EEE$!Qa1EEEr )r! r# r" c 3 X K | ]$}t |j d V %dS )r N)r5 model_input_names)r) input_slicer s r r7 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 r5 r
intfloatr0 ndarraytypeitemsr _get_padding_strategiesallvaluesrange _truncateappendr LONGESTmax
MAX_LENGTH_paddtypefloat64astypefloat32)r r r r! r" r# r r$ required_input
first_elementindexr+ valuer> truncated_inputsinputs inputs_slice
batch_outputsoutputsr6 r: s `` @@r padz SequenceFeatureExtractor.pad3 s L (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
! }--
!%MCeRZ+PQQ
!% K} K K]8K8K K K K
-2244 G GJC%(S%L11
G*25//"3'' rz22
G +G*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 r> 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 r. )rU r )r r constant)constant_valuesleftzInvalid padding strategy:)r< r rQ r5
DO_NOT_PADr0 onesint32r rb r r rE str)
r r r! r> r# r rY needs_to_be_padded
difference
padding_shapes
r rT 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 r. )rE r< r5 )r r r! r# r" rY needs_to_be_truncateds r rO z"SequenceFeatureExtractor._truncate( s . l% %
lJ . jkk k+D,B1,EF !&8&D*WiJimnJnJn%);;q@DVVJ #N 3 3j @ i s r rK z0SequenceFeatureExtractor._get_padding_strategiesS s % $#2#: 99
+#27#;#; G_55
+#* . 9 ?#=== ro.Hrrr
9 9 9t?Q?Y ]
r audio_url_or_urlsc F rn j t |t r*t |d t s fd|D S t |t rt | S t
| r|S t dt | )z
Convert a single or a list of urls into the corresponding `np.ndarray` objects.
If a single url is passed, the return value will be a single object. If a list is passed a list of objects is
returned.
r c > g | ]} | S )r ) fetch_audio)r) xr r s r r, z8SequenceFeatureExtractor.fetch_audio..} s, ```D$$Qm$DD```r rt z=only a single or a list of entries is supported but got type=) r r@ rA rG rj r r TypeErrorrI )r rq r s ` `r ru z$SequenceFeatureExtractor.fetch_audios s *7N
Dr s 3 3 3 3 3 3 3 3 J J J J J J J J R R R R R R R R R R R R R R
H % %gw gw gw gw gw 5 gw gw gw gw gwr