Hugging Face's logo

Transformers documentation

UnivNet

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Ce modèle a été publié dans les papiers HF le 2021-06-15 et a été ajouté à Hugging Face Transformers le 2023-11-22.

UnivNet

Aperçu

The UnivNet model was proposed in UnivNet: A Neural Vocoder with Multi-Resolution Spectrogram Discriminators for High-Fidelity Waveform Generation by Won Jang, Dan Lim, Jaesam Yoon, Bongwan Kin, and Juntae Kim. The UnivNet model is a generative adversarial network (GAN) trained to synthesize high fidelity speech waveforms. The UnivNet model shared in transformers is the generator, which maps a conditioning log-mel spectrogram and optional noise sequence to a speech waveform (e.g. a vocoder). Only the generator is required for inference. The discriminator used to train the generator is not implemented.

L'abstract de l'article est le suivant :

La plupart des vocodeurs neuronaux utilisent des mélospectrogrammes à bande limitée pour générer des formes d’onde. Si des caractéristiques spectrales pleine bande sont utilisées en entrée, le vocodeur peut recevoir le maximum d’informations acoustiques possible. Cependant, dans certains modèles utilisant des mélospectrogrammes pleine bande, un problème de lissage excessif se produit, entraînant la génération de spectrogrammes peu nets. Pour remédier à ce problème, nous proposons UnivNet, un vocodeur neuronal qui synthétise des formes d’onde haute fidélité en temps réel. Inspirés par des travaux dans le domaine de la détection d’activité vocale, nous avons ajouté un discriminateur de spectrogrammes multi-résolution qui utilise plusieurs amplitudes de spectrogrammes linéaires calculées à l’aide de divers ensembles de paramètres. En utilisant des mélospectrogrammes pleine bande en entrée, nous nous attendons à générer des signaux haute résolution en ajoutant un discriminateur qui utilise des spectrogrammes de plusieurs résolutions en entrée. Lors d’une évaluation sur un jeu de données contenant des informations sur des centaines de locuteurs, UnivNet a obtenu les meilleurs résultats objectifs et subjectifs parmi les modèles concurrents, tant pour les locuteurs vus que non vus. Ces résultats, y compris le meilleur score subjectif pour la synthèse vocale, démontrent le potentiel d’une adaptation rapide à de nouveaux locuteurs sans avoir besoin d’un entraînement à partir de zéro.

Astuces :

  • L'argument noise_sequence de UnivNetModel.forward() doit être un bruit gaussien standard (tel que celui produit par torch.randn) de forme ([batch_size], noise_length, model.config.model_in_channels), où noise_length doit correspondre à la dimension de longueur (dimension 1) de l'argument input_features. S'il n'est pas fourni, il sera généré aléatoirement ; un torch.Generator peut être fourni à l'argument generator afin que le passage avant (forward pass) puisse être reproduit. (Notez que UnivNetFeatureExtractor renvoie du bruit généré par défaut, il ne devrait donc pas être nécessaire de générer noise_sequence manuellement.)
  • Le padding ajouté par UnivNetFeatureExtractor peut être retiré de la sortie de UnivNetModel à l’aide de la méthode UnivNetFeatureExtractor.batch_decode(), comme le montre l’exemple d’utilisation ci-dessous.
  • L'ajout de silence à la fin de chaque forme d'onde peut réduire les artefacts en fin d'échantillon audio généré. Il est possible de le faire en transmettant pad_end = True à UnivNetFeatureExtractor.call(). Consultez ce problème pour plus de détails.

Exemple d'utilisation :

import torch
from datasets import Audio, load_dataset
from scipy.io.wavfile import write

from transformers import UnivNetFeatureExtractor, UnivNetModel


model_id_or_path = "dg845/univnet-dev"
model = UnivNetModel.from_pretrained(model_id_or_path, device_map="auto")
feature_extractor = UnivNetFeatureExtractor.from_pretrained(model_id_or_path)

ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
# Resample the audio to the model and feature extractor's sampling rate.
ds = ds.cast_column("audio", Audio(sampling_rate=feature_extractor.sampling_rate))
# Pad the end of the converted waveforms to reduce artifacts at the end of the output audio samples.
inputs = feature_extractor(
    ds[0]["audio"]["array"], sampling_rate=ds[0]["audio"]["sampling_rate"], pad_end=True, return_tensors="pt"
)

with torch.no_grad():
    audio = model(**inputs)

# Remove the extra padding at the end of the output.
audio = feature_extractor.batch_decode(**audio)[0]
# Convert to wav file
write("sample_audio.wav", feature_extractor.sampling_rate, audio)

Ce modèle a été contribué par dg845. À ma connaissance, il n'existe pas de publication officielle du code, mais une implémentation non officielle peut être trouvée sur maum-ai/univnet avec des points de contrôle pré-entraînés ici.

UnivNetConfig

classe transformers.UnivNetConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonemodel_in_channels: int = 64model_hidden_channels: int = 32num_mel_bins: int = 100resblock_kernel_sizes: list[int] | tuple[int, ...] = (3, 3, 3)resblock_stride_sizes: list[int] | tuple[int, ...] = (8, 8, 4)resblock_dilation_sizes: list | tuple = ((1, 3, 9, 27), (1, 3, 9, 27), (1, 3, 9, 27))kernel_predictor_num_blocks: int = 3kernel_predictor_hidden_channels: int = 64kernel_predictor_conv_size: int = 3kernel_predictor_dropout: float | int = 0.0initializer_range: float = 0.01leaky_relu_slope: float = 0.2 )

Paramètres

  • model_in_channels (int, facultatif, valeur par défaut 64) — Le nombre de canaux d’entrée pour le réseau résiduel UnivNet. Cette valeur doit correspondre à noise_sequence.shape[1] et à la valeur utilisée dans la classe UnivNetFeatureExtractor.
  • model_hidden_channels (int, facultatif, valeur par défaut : 32) — Le nombre de canaux cachés de chaque bloc résiduel dans le réseau résiduel UnivNet.
  • num_mel_bins (int, facultatif, valeur par défaut 100) — Le nombre de bandes de fréquence dans le spectrogramme log-mel de conditionnement. Cette valeur doit correspondre à celle utilisée dans la classe UnivNetFeatureExtractor.
  • resblock_kernel_sizes (tuple[int] ou list[int], facultatif, par défaut [3, 3, 3]) — Un tuple d'entiers définissant les tailles de noyau des couches de convolution 1D dans le réseau résiduel UnivNet. La longueur de resblock_kernel_sizes définit le nombre de blocs resnet et doit correspondre à celle de resblock_stride_sizes et resblock_dilation_sizes.
  • resblock_stride_sizes (tuple[int] ou list[int], facultatif, par défaut [8, 8, 4]) — Un tuple d'entiers définissant les tailles de pas des couches de convolution 1D du réseau résiduel UnivNet. La longueur de resblock_stride_sizes doit correspondre à celle de resblock_kernel_sizes et de resblock_dilation_sizes.
  • resblock_dilation_sizes (tuple[tuple[int]] ou list[list[int]], facultatif, par défaut [[1, 3, 9, 27], [1, 3, 9, 27], [1, 3, 9, 27]]) — Un tuple imbriqué d'entiers définissant les taux de dilatation des couches de convolution 1D dilatées du réseau résiduel de UnivNet. La longueur de resblock_dilation_sizes doit correspondre à celle de resblock_kernel_sizes et de resblock_stride_sizes. La longueur de chaque liste imbriquée dans resblock_dilation_sizes définit le nombre de couches de convolution par bloc resnet.
  • kernel_predictor_num_blocks (int, facultatif, valeur par défaut : 3) — Le nombre de blocs résiduels dans le réseau du prédicteur de noyaux, qui calcule le noyau et le biais pour chaque couche de convolution à variables de position du réseau résiduel UnivNet.
  • kernel_predictor_hidden_channels (int, facultatif, valeur par défaut : 64) — Le nombre de canaux cachés pour chaque bloc résiduel du réseau de prédiction de noyau.
  • kernel_predictor_conv_size (int, facultatif, valeur par défaut : 3) — Taille du noyau de chaque couche de convolution 1D dans le réseau de prédiction de noyau.
  • kernel_predictor_dropout (float, facultatif, valeur par défaut 0.0) — Probabilité de dropout pour chaque bloc résiduel du réseau de prédiction de noyau.
  • initializer_range (float, facultatif, par défaut 0.01) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids.
  • leaky_relu_slope (float, facultatif, valeur par défaut 0.2) — L'angle de la pente négative utilisé par l'activation leaky ReLU.

Ceci est la classe de configuration destinée à stocker la configuration d'un UnivNetModel. Elle est utilisée pour instancier un modèle Univnet en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de dg845/univnet-dev

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Exemple :

>>> from transformers import UnivNetModel, UnivNetConfig

>>> # Initializing a Tortoise TTS style configuration
>>> configuration = UnivNetConfig()

>>> # Initializing a model (with random weights) from the Tortoise TTS style configuration
>>> model = UnivNetModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

UnivNetFeatureExtractor

classe transformers.UnivNetFeatureExtractor

< >

( feature_size: int = 1sampling_rate: int = 24000padding_value: float = 0.0do_normalize: bool = Falsenum_mel_bins: int = 100hop_length: int = 256win_length: int = 1024win_function: str = 'hann_window'filter_length: int | None = 1024max_length_s: int = 10fmin: float = 0.0fmax: float | None = Nonemel_floor: float = 1e-09center: bool = Falsecompression_factor: float = 1.0compression_clip_val: float = 1e-05normalize_min: float = -11.512925148010254normalize_max: float = 2.3143386840820312model_in_channels: int = 64pad_end_length: int = 10return_attention_mask = True**kwargs )

Paramètres

  • feature_size (int, facultatif, valeur par défaut 1) — La dimension des caractéristiques des fonctionnalités extraites.
  • sampling_rate (int, facultatif, valeur par défaut : 24000) — Fréquence d'échantillonnage à laquelle les fichiers audio doivent être numérisés, exprimée en hertz (Hz).
  • padding_value (float, facultatif, par défaut 0.0) — La valeur utilisée pour l’ajustement lors de l’application de la stratégie définie par l’argument padding à UnivNetFeatureExtractor.call(). Elle doit correspondre au silence audio. L’argument pad_end de __call__ utilisera également cette valeur.
  • do_normalize (bool, facultatif, valeur par défaut False) — Indique s'il faut effectuer la normalisation Tacotron 2 sur l'entrée. La normalisation peut contribuer à améliorer considérablement les performances de certains modèles.
  • num_mel_bins (int, facultatif, valeur par défaut 100) — Le nombre de bandes de fréquence mélo dans les caractéristiques du spectrogramme extrait. Cette valeur doit correspondre à UnivNetModel.config.num_mel_bins.
  • hop_length (int, facultatif, par défaut 256) — Nombre direct d'échantillons entre les fenêtres glissantes. Ce paramètre est également appelé « shift » dans de nombreux articles. Notez que cela diffère d'autres extracteurs de caractéristiques audio, tels que SpeechT5FeatureExtractor, qui expriment hop_length en millisecondes.
  • win_length (int, facultatif, par défaut 1024) — Le nombre direct d'échantillons pour chaque fenêtre glissante. Notez que cela diffère d'autres extracteurs de caractéristiques audio tels que SpeechT5FeatureExtractor, qui prennent win_length en millisecondes.
  • win_function (str, facultatif, par défaut "hann_window") — Nom de la fonction de fenêtre utilisée pour le fenêtrage, doit être accessible via torch.{win_function}
  • filter_length (int, facultatif, valeur par défaut 1024) — Le nombre de composantes FFT à utiliser. Si None, cette valeur est déterminée à l'aide de transformers.audio_utils.optimal_fft_length.
  • max_length_s (int, facultatif, valeur par défaut 10) — La longueur maximale de l'entrée du modèle, en secondes. Cette valeur est utilisée pour compléter l'audio.
  • fmin (float, facultatif, valeur par défaut 0.0) — Fréquence mélinique minimale en Hz.
  • fmax (float, facultatif) — Fréquence mel maximale en Hz. Si non définie, la valeur par défaut est sampling_rate / 2.
  • mel_floor (float, facultatif, valeur par défaut 1e-09) — Valeur minimale des banques de fréquences mel. Notez que la manière dont UnivNetFeatureExtractor utilise mel_floor est différente de celle de transformers.audio_utils.spectrogram().
  • center (bool, facultatif, par défaut False) — Indique s'il faut ajouter des zéros à la forme d'onde afin que la trame t soit centrée sur le temps t * hop_length. Si False, la trame t commence au temps t * hop_length.
  • compression_factor (float, facultatif, valeur par défaut 1.0) — Facteur de compression multiplicatif pour la compression de la plage dynamique lors de la normalisation spectrale.
  • compression_clip_val (float, facultatif, valeur par défaut : 1e-05) — Valeur de clip appliquée à la forme d'onde avant l'application de la compression de plage dynamique lors de la normalisation spectrale.
  • normalize_min (float, facultatif, valeur par défaut : -11.512925148010254) — Valeur minimale utilisée pour la normalisation linéaire de type Tacotron 2. La valeur par défaut est la valeur originale de l'implémentation Tacotron 2.
  • normalize_max (float, facultatif, valeur par défaut 2.3143386840820312) — La valeur maximale utilisée pour la normalisation linéaire de type Tacotron 2. La valeur par défaut est la valeur originale de l'implémentation Tacotron 2.
  • model_in_channels (int, facultatif, valeur par défaut : 64) — Le nombre de canaux d'entrée du modèle UnivNetModel. Cette valeur doit correspondre à UnivNetModel.config.model_in_channels.
  • pad_end_length (int, facultatif, valeur par défaut 10) — Lors de l'ajout de padding à la fin de chaque forme d'onde, nombre d'échantillons correspondant aux trames du spectrogramme à ajouter. Le nombre d'échantillons ajoutés sera pad_end_length * hop_length.
  • return_attention_mask (bool, facultatif, par défaut True) — Indique si call() doit retourner attention_mask.

Construit un extracteur de caractéristiques UnivNet.

Cette classe extrait les caractéristiques de la banque de filtres log-mel à partir de la parole brute en utilisant la transformée de Fourier de court terme (STFT). L’implémentation de la STFT suit celle de TacoTron 2 et Hifi-GAN.

Cet extracteur de fonctionnalités hérite de SequenceFeatureExtractor, qui contient la plupart des méthodes principales. Les utilisateurs doivent se référer à cette superclasse pour plus d'informations sur ces méthodes.

__call__

< >

( raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]]sampling_rate: int | None = Nonepadding: bool | str | transformers.utils.generic.PaddingStrategy = Truemax_length: int | None = Nonetruncation: bool = Truepad_to_multiple_of: int | None = Nonereturn_noise: bool = Truegenerator: numpy.random._generator.Generator | None = Nonepad_end: bool = Falsepad_length: int | None = Nonedo_normalize: str | None = Nonereturn_attention_mask: bool | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = None )

Paramètres

  • raw_speech (np.ndarray, list[float], list[np.ndarray], list[list[float]]) — La séquence ou le lot de séquences à compléter. Chaque séquence peut être un tableau numpy, une liste de valeurs flottantes, une liste de tableaux numpy ou une liste de listes de valeurs flottantes. L’audio doit être en mono, pas en stéréo, c’est-à-dire un seul flottant par pas de temps.
  • sampling_rate (int, facultatif) — La fréquence d’échantillonnage à laquelle l’entrée raw_speech a été échantillonnée. Il est fortement recommandé de passer sampling_rate lors de l’appel forward afin d’éviter les erreurs silencieuses et de permettre le pipeline de reconnaissance automatique de la parole.
  • padding (bool, str ou PaddingStrategy, facultatif, valeur par défaut True) — Sélectionne une stratégie pour mettre en forme les formes d'onde raw_speech des signaux audio bruts (selon le côté de mise en forme et l'indice de mise en forme du modèle) parmi les options suivantes :
    • True ou 'longest' : Ajuster à la séquence la plus longue du lot (ou aucun ajustement si une seule séquence est fournie).
    • 'max_length' : Remplir jusqu'à une longueur maximale spécifiée par l'argument max_length ou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni.
    • False ou 'do_not_pad' (par défaut) : aucun padding (c’est-à-dire, peut produire un lot avec des séquences de longueurs différentes).

    Si pad_end = True, ce bourrage sera effectué avant l'application de la stratégie padding.

  • max_length (int, facultatif) — Longueur maximale de la liste renvoyée et, le cas échéant, longueur du bourrage (voir ci-dessus).
  • truncation (bool, facultatif, par défaut True) — Active la troncature pour couper les séquences d'entrée plus longues que max_length à max_length.
  • pad_to_multiple_of (int, facultatif) — Si défini, la séquence est rembourrée jusqu'à un multiple de la valeur fournie.

    Ceci est particulièrement utile pour permettre l'utilisation des Tensor Cores sur le matériel NVIDIA avec une capacité de calcul >= 7.5 (Volta), ou sur les TPU qui bénéficient d'avoir des longueurs de séquence qui sont un multiple de 128.

  • return_noise (bool, facultatif, par défaut True) — Indique s'il faut générer et renvoyer une forme d'onde de bruit à utiliser dans UnivNetModel.forward().
  • generator (numpy.random.Generator, facultatif, par défaut None) — Générateur de nombres aléatoires numpy.random.Generator facultatif à utiliser lors de la génération du bruit.
  • pad_end (bool, facultatif, par défaut False) — Indique s'il faut ajouter du silence à la fin de chaque forme d'onde. Cela peut aider à réduire les artefacts en fin d'échantillon audio généré ; voir https://github.com/seungwonpark/melgan/issues/8 pour plus de détails. Ce bourrage sera effectué avant l'application de la stratégie de bourrage spécifiée dans padding.
  • pad_length (int, facultatif, par défaut None) — Lors de l'ajout d'un remplissage à la fin de chaque forme d'onde, la longueur du remplissage en trames de spectrogramme. Si non défini, cette valeur est par défaut self.config.pad_end_length.
  • do_normalize (bool, facultatif) — Indique s'il faut effectuer la normalisation Tacotron 2 sur l'entrée. La normalisation peut contribuer à améliorer significativement les performances de certains modèles. Si non défini, la valeur par défaut est self.config.do_normalize.
  • return_attention_mask (bool, facultatif) — Indique s'il faut retourner le masque d'attention. Si la valeur par défaut est conservée, le masque d'attention est retourné selon la valeur par défaut du feature_extractor spécifique.

    Qu'est-ce que les masques d'attention ?

  • return_tensors (str ou TensorType, facultatif) — Si défini, renvoie des tenseurs au lieu d'une liste d'entiers Python. Les valeurs acceptées sont :
    • 'pt' : Renvoie des objets torch.np.array de PyTorch.
    • 'np' : Renvoie des objets Numpy np.ndarray.

Méthode principale pour vectoriser et préparer une ou plusieurs séquences pour le modèle.

UnivNetModel

classe transformers.UnivNetModel

< >

( config: UnivNetConfig )

Paramètres

  • config (UnivNetConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.

Le modèle Univnet brut, qui produit des états cachés bruts sans aucune tête spécifique au sommet.

Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)

Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.

forward

< >

( input_features: Tensornoise_sequence: typing.Optional[torch.Tensor] = Nonepadding_mask: typing.Optional[torch.Tensor] = Nonegenerator: typing.Optional[torch.Generator] = Nonereturn_dict: bool | None = None**kwargs ) → UnivNetModelOutput or tuple(torch.Tensor)

Paramètres

  • input_features (torch.Tensor de forme (batch_size, sequence_length, feature_dim)) — Les tenseurs correspondant aux caractéristiques audio d’entrée. Les caractéristiques audio peuvent être obtenues à l’aide de UnivNetFeatureExtractor. Voir UnivNetFeatureExtractor.call() pour plus de détails (processor_class utilise UnivNetFeatureExtractor pour le traitement des audios).
  • noise_sequence (torch.Tensor, facultatif) — Tenseur contenant une séquence de bruit de bruit gaussien standard. Peut être groupé (batched) et de forme (batch_size, sequence_length, config.model_in_channels), ou non groupé et de forme (sequence_length, config.model_in_channels)`. S'il n'est pas fourni, il sera généré aléatoirement.
  • padding_mask (torch.BoolTensor, facultatif) — Masque indiquant quelles parties de chaque séquence sont remplies par du bourrage. Les valeurs du masque sont choisies dans [0, 1]:
    • 1 pour les jetons qui ne sont pas masqués
    • 0 pour les jetons masqués

    Le masque peut être groupé et de forme (batch_size, sequence_length) ou non groupé et de forme (sequence_length,).

  • generator (torch.Generator, facultatif) — Un générateur torch pour rendre la génération déterministe. return_dict : Indique s'il faut retourner une sous-classe de ModelOutput plutôt qu'un simple tuple.
  • return_dict (bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.

Retourne

UnivNetModelOutput ou tuple(torch.Tensor)

Un UnivNetModelOutput ou un tuple de torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (UnivNetConfig) et des entrées.

La méthode forward du modèle UnivNetModel redéfinit la méthode spéciale __call__.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance Module plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

  • formes d’onde (torch.Tensor de forme (batch_size, sequence_length)) — Formes d’onde audio de sortie 1D (mono-canal) par lot.
  • waveform_lengths (torch.Tensor de forme (batch_size,)) — La longueur en échantillons de chaque forme d’onde non rembourrée du lot dans waveforms.

Exemple :

>>> from transformers import UnivNetFeatureExtractor, UnivNetModel
>>> from datasets import load_dataset, Audio

>>> model = UnivNetModel.from_pretrained("dg845/univnet-dev")
>>> feature_extractor = UnivNetFeatureExtractor.from_pretrained("dg845/univnet-dev")

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> # Resample the audio to the feature extractor's sampling rate.
>>> ds = ds.cast_column("audio", Audio(sampling_rate=feature_extractor.sampling_rate))
>>> inputs = feature_extractor(
...     ds[0]["audio"]["array"], sampling_rate=ds[0]["audio"]["sampling_rate"], return_tensors="pt"
... )
>>> audio = model(**inputs).waveforms
>>> list(audio.shape)
[1, 140288]
Update on GitHub

←UniSpeech-SAT VibeVoice→