AI Endpoints - Transcription Audio

Introduction

AI Endpoints est une plateforme serverless proposée par OVHcloud qui offre un accès simplifié à une sélection de modèles d'IA pré-entraînés, mondialement reconnus. La plateforme est conçue pour être simple, sécurisée et intuitive, ce qui en fait une solution idéale pour les développeurs souhaitant enrichir leurs applications avec des capacités d'IA sans expertise poussée en IA ni préoccupations sur la confidentialité des données.

La transcription audio (Speech to Text) est une fonctionnalité puissante qui permet de convertir un langage parlé en texte écrit.

Les API de transcription audio sur AI Endpoints vous permettent d'intégrer facilement cette technologie dans vos applications, en transcrivant vos fichiers audio avec une grande précision. Nos endpoints prennent en charge différents formats audio et proposent des options de configuration flexibles pour répondre à vos besoins spécifiques.

Objectif

Cette documentation présente un aperçu des endpoints de transcription audio proposés sur AI Endpoints.

Consultez notre Catalogue pour découvrir quels modèles sont compatibles avec l'analyse audio.

Les exemples fournis dans ce guide peuvent être utilisés avec l'un des environnements suivants :

pip install openai pydantic

npm install request

Ces exemples utilisent le modèle Whisper-large-v3.

Authentification et limitation du débit

Tous les exemples fournis dans ce guide utilisent une authentification anonyme, ce qui simplifie leur usage mais peut entraîner des limitations de débit (rate limiting). Si vous souhaitez activer l'authentification avec votre propre token, indiquez simplement votre clé API dans les requêtes.

Suivez les instructions du guide AI Endpoints - Premiers pas pour plus d'informations sur l'authentification.

Corps de la requête

Aperçu des paramètres

Le corps de la requête pour l'endpoint de transcription audio est de type multipart/form-data et comprend les champs suivants :

Exemple d'utilisation

Maintenant que vous connaissez les paramètres disponibles, voyons comment les mettre en pratique. Voici des exemples de requêtes en Python, cURL et JavaScript :

import os
import requests

url = "https://oai.endpoints.kepler.ai.cloud.ovh.net/v1/audio/transcriptions"

audio_file_path = "my_audio.mp3"

headers = {
   "accept": "application/json",
#   "Authorization": f"Bearer {os.getenv('OVH_AI_ENDPOINTS_ACCESS_TOKEN')}",
}

files = {"file": open(audio_file_path, "rb")}

data = {
    "model": "whisper-large-v3",
    "language": "en",
    "temperature": "0",
    "prompt": "<|transcribe|>",
    "diarize": "false",
    "timestamp_granularities": ["segment"],
    "response_format": "verbose_json"
}

response = requests.post(url, headers=headers, files=files, data=data)

if response.status_code == 200:
    # Handle response
    print(response.json())
else:
    print("Error:", response.status_code, response.text)

from openai import OpenAI
import os

url = "https://oai.endpoints.kepler.ai.cloud.ovh.net/v1/"
audio_file_path = "my_audio.mp3"

client = OpenAI(
    base_url=url,
#    api_key=os.getenv('OVH_AI_ENDPOINTS_ACCESS_TOKEN'),
    )

with open(audio_file_path, "rb") as f:
    transcript = client.audio.transcriptions.create(
        file=f,
        model="whisper-large-v3",
        language="en",
        temperature=0,
        prompt="<|transcribe|>",
        timestamp_granularities=["segment"],
        response_format="verbose_json"
    )

print(transcript)

curl -X POST "https://oai.endpoints.kepler.ai.cloud.ovh.net/v1/audio/transcriptions" \
-F "file=@my_audio.mp3" \
-F "model=whisper-large-v3" \
-F "language=en" \
-F "temperature=0" \
-F "prompt=<|transcribe|>" \
-F "diarize=false" \
-F "timestamp_granularities[]=segment" \
-F "response_format=verbose_json"

`-H "Authorization: Bearer $OVH_AI_ENDPOINTS_ACCESS_TOKEN" \`

import OpenAI from "openai";
import fs from "fs";

const openai = new OpenAI({
 baseURL: "https://oai.endpoints.kepler.ai.cloud.ovh.net/v1/",
 // apiKey: process.env.OVH_AI_ENDPOINTS_ACCESS_TOKEN,
});

const transcript = await openai.audio.transcriptions.create({
  file: fs.createReadStream("my_audio.mp3"),
  model: "whisper-large-v3",
  language: "en",
  temperature: 0,
  prompt: "<|transcribe|>",
  timestamp_granularities: ["segment"],
  response_format: "verbose_json"
});

console.log(transcript);

Exemple de sortie

Par défaut, l'endpoint de transcription renvoie une sortie au format verbose_json.

Elle inclut des métadonnées détaillées telles que la langue, les segments, les tokens et les informations de diarisation :

{
  "task": "transcribe",
  "success": true,
  "language": "en",
  "duration": 4.46975,
  "text": "My name is Octave and I am working at OVHcloud",
  "words": [],
  "segments": [
    {
      "id": 1,
      "seek": 0,
      "start": 0,
      "end": 3.48,
      "text": "My name is Octave and I am working at OVHcloud",
      "tokens": [
        50365,
        2588,
        275,
        ...
      ],
      "temperature": 0,
      "avg_logprob": -0.38066408,
      "compression_ratio": 0.9,
      "no_speech_prob": 0
    }
  ],
  "diarization": [],
  "usage": {
    "type": "duration",
    "seconds": 5
  }
}

Pour des exemples détaillés de chaque type de sortie disponible, consultez la section Formats de réponse.

Détails des paramètres

Si l'aperçu précédent fournit une référence rapide, certains paramètres nécessitent plus de contexte pour comprendre comment et quand les utiliser.

Diarisation

Le paramètre diarize active la séparation des locuteurs dans la transcription générée. Lorsqu'il est réglé sur true, le système étiquette les différentes voix comme Speaker 0, Speaker 1, etc.

C'est utile pour les réunions, débats ou interviews où plusieurs personnes s'expriment.

Exemple de sortie : transcription d'un fichier audio avec diarize activé :

Requête :

{
  "file": "<audio file object>",
  "diarize": true
}

Sortie :

{
  "task":"transcribe",
  "success":true,
  "language":"en",
  "duration":8.939875,
  "text":"Hello Marie, your recent experiments are fascinating. Indeed, Albert. It's exciting to explore radioactivity together.",
  "words":[],
  "segments":[
    {"id":1,"seek":0,"start":0.0,"end":3.24,"text":"Hello Marie, your recent experiments are fascinating.","tokens":[50365,5490,...,13,50543],"temperature":0.0,"avg_logprob":-0.21679688,"compression_ratio":1.0361446,"no_speech_prob":0.0},
    {"id":2,"seek":0,"start":4.74,"end":8.1,"text":"Indeed, Albert. It's exciting to explore radioactivity together.","tokens":[50597,2421,..., 30,50780],"temperature":0.0,"avg_logprob":-0.21679688,"compression_ratio":1.0361446,"no_speech_prob":0.0}
  ],
  "diarization":[
    {"speaker":0,"text":"Hello Marie","start":0.0,"end":1.06},
    {"speaker":0,"text":"your recent experiments are fascinating.","start":1.16,"end":3.24},
    {"speaker":1,"text":"Indeed, Albert","start":4.74,"end":6.76},
    {"speaker":1,"text":"It's exciting to explore radioactivity together.","start":6.98,"end":8.1}
  ],
  "usage":{"type":"duration","seconds":9.0}
}

Prompt

Le paramètre prompt vous permet de fournir un contexte supplémentaire pour améliorer la transcription. Voyez-le comme un indice donné au modèle avant qu'il n'écoute votre audio. Cela peut être utile pour :

• Corriger des mots ou acronymes souvent mal reconnus.
• Préserver le contexte si l'audio est découpé en plusieurs parties.
• Renforcer la ponctuation, les mots de remplissage ou le style d'écriture.
• Traduire la parole générée vers l'anglais.

Exemples

{
    "file": <audio file object>,
    "prompt": "OVHcloud, Grand Palais, CNRS."
}

{
     "file": <audio file object>,
     "prompt": "<|translate|>"
}

{
     "file": <audio file object>,
     "prompt": "...previous segment transcript..."
}

{
    "file": <audio file object>,
    "prompt": "Hello, welcome to my lecture on the history of France."
}

{
    "file": <audio file object>,
    "prompt": "Uh, well, let me think... hmm, okay, so about OVHcloud."
}

{
    "file": <audio file object>,
    "prompt": "以下是普通话的句子。"
}

{
    "file": <audio file object>,
    "prompt": "以下是普通話的句子。"
}

Granularité des horodatages

Le paramètre timestamp_granularities contrôle le niveau des marqueurs temporels inclus dans la transcription. Vous disposez de trois options :

{
    "file": <audio file object>,
    "timestamp_granularities": ["segment"],
    "response_format": verbose_json
}

words=[],
segments=[
   {
       'id': 1,
       'seek': 0,
       'start': 1.76,
       'end': 4.58,
       'text': ' France is the world's leading tourist destination',
       'tokens': [
           50365,
           1456,
           1181,
           ...
       ],
       'temperature': 0.0, 'avg_logprob': -0.14139344,
       'compression_ratio': 1.2769231,
       'no_speech_prob': 0.007171631
   },
   {
       'id': 2,
       'seek': 0,
       'start': 9.44,
       'end': 14.92,
       'text': 'having received 100 million foreign visitors in 2023.',
       'tokens': [
           50609,
           4042,
           25011,
           ...
       ],
       'temperature': 0.0,
       'avg_logprob': -0.14139344,
       'compression_ratio': 1.2769231,
       'no_speech_prob': 0.007171631
       },
   ...
]

{
    "file": <audio file object>,
    "timestamp_granularities": ["word"],
    "response_format": verbose_json
}

words=[
    {'word': 'France', 'start': 1.76, 'end': 2.44}, 
    {'word': 'is', 'start': 2.44, 'end': 3.12}, 
    {'word': 'the', 'start': 3.12, 'end': 3.96}, 
    {'word': 'world', 'start': 3.96, 'end': 4.08},
    ...
],
segments=[]

{
    "file": <audio file object>,
    "timestamp_granularities": ["word", "segment"],
    "response_format": verbose_json
}

words=[
    {'word': 'France', 'start': 1.76, 'end': 2.44}, 
    {'word': 'is', 'start': 2.44, 'end': 3.12}, 
    {'word': 'the', 'start': 3.12, 'end': 3.96}, 
    {'word': 'world', 'start': 3.96, 'end': 4.08},
    ...
],
segments=[
   {
       'id': 1,
       'seek': 0,
       'start': 1.76,
       'end': 4.58,
       'text': ' France is the world's leading tourist destination',
       'tokens': [
           50365,
           1456,
           1181,
           ...
       ],
       'temperature': 0.0, 'avg_logprob': -0.14139344,
       'compression_ratio': 1.2769231,
       'no_speech_prob': 0.007171631
   },
   {
       'id': 2,
       'seek': 0,
       'start': 9.44,
       'end': 14.92,
       'text': 'having received 100 million foreign visitors in 2023.',
       'tokens': [
           50609,
           4042,
           25011,
           ...
       ],
       'temperature': 0.0,
       'avg_logprob': -0.14139344,
       'compression_ratio': 1.2769231,
       'no_speech_prob': 0.007171631
       },
   ...
]

Formats de réponse

Le response_format détermine le format de retour des données de transcription. Les formats disponibles sont :

{
  "task": "transcribe",
  "success": true,
  "language": "en",
  "duration": 4.46975,
  "text": "My name is Octave and I am working at OVHcloud.",
  "words": [],
  "segments": [
    {
      "id": 1,
      "seek": 0,
      "start": 0,
      "end": 3.48,
      "text": "My name is Octave and I am working at OVHcloud.",
      "tokens": [
        50365,
        2588,
        275,
        ...
      ],
      "temperature": 0,
      "avg_logprob": -0.38066408,
      "compression_ratio": 0.9,
      "no_speech_prob": 0
    }
  ],
  "diarization": [],
  "usage": {
    "type": "duration",
    "seconds": 5
  }
}

{
  "text": "My name is Octave and I am working at OVHcloud.",
  "usage": {
    "type": "duration",
    "seconds": 5
  }
}

My name is Octave and I am working at OVHcloud

Stratégie de segmentation (Chunking Strategy)

Le paramètre chunking_strategy contrôle la façon dont le fichier audio est découpé en segments plus petits avant la transcription.

Par défaut, lorsqu'il n'est pas défini, l'audio est traité comme un seul bloc.

Définir chunking_strategy découpe l'audio à l'aide de la détection d'activité vocale (VAD) et transcrit les segments obtenus par lots. Cela accélère la transcription des fichiers longs (environ 1,5× pour quelques minutes d'audio, jusqu'à environ 2× sur les enregistrements longs), tout en conservant une qualité de transcription très proche du mode bloc unique. Le chunking n'apporte aucun gain de vitesse sur les fichiers très courts (moins de ~30 secondes).

Ce paramètre prend en charge deux valeurs, auto et server_vad.

Lorsqu'il est réglé sur auto, le système normalise d'abord le volume audio, puis utilise la détection d'activité vocale (VAD) pour découper automatiquement l'audio aux pauses naturelles (silences).

Vous pouvez également fournir un objet server_vad pour ajuster manuellement les paramètres de détection VAD. Cela vous permet de contrôler les paramètres suivants :

• prefix_padding_ms : quantité d'audio à inclure avant la parole détectée par la VAD (en millisecondes).
• silence_duration_ms : durée de silence requise pour détecter la fin de la parole (en millisecondes). Des valeurs plus faibles rendent le modèle plus réactif, mais peuvent accroître sa sensibilité aux courtes pauses.
• threshold : seuil de sensibilité (0.0 à 1.0) de la VAD. Des valeurs plus élevées nécessitent une parole plus forte et peuvent donner de meilleurs résultats dans des environnements bruyants.

Exemple :

{
  "file": "<audio file object>",
  "chunking_strategy": {
    "type": "server_vad",
    "prefix_padding_ms": 200,
    "silence_duration_ms": 500,
    "threshold": 0.6
  }
}

Limites de l'endpoint

Compatibilité et performances par langue

Les modèles Whisper sont compatibles avec un large éventail de langues, prenant en charge environ 100 langues au total.

Cependant, la qualité et la vitesse de transcription dépendent de la langue de l'audio fourni. Bien que les modèles Whisper v3 soient multilingues, leur précision varie sensiblement selon la langue :

• Les langues courantes comme l'anglais, le français, l'espagnol et l'allemand offrent généralement les meilleurs résultats.
• Les langues moins courantes ou disposant de peu de ressources peuvent produire une précision plus faible ou des temps de traitement plus longs.
• Les accents régionaux, dialectes, ou le changement de langue au sein d'un même enregistrement (code-switching) peuvent réduire davantage la précision.

Fournir explicitement le paramètre language (plutôt que de s'appuyer sur la détection automatique) améliore généralement la précision et la latence. Le format attendu est le format ISO-639-1 (par exemple en pour l'anglais, fr pour le français, de pour l'allemand, es pour l'espagnol, zh pour le chinois, ar pour l'arabe, etc.).

Pour une analyse détaillée des performances par langue, consultez les résultats de benchmark de Whisper. Cela inclut les taux d'erreur sur les mots (WER) et sur les caractères (CER) selon différents jeux de données.

Longueur du prompt

Pour les modèles basés sur Whisper, le paramètre prompt ne prend en compte que les 224 derniers tokens (soit environ les 200 derniers caractères). Si votre prompt est plus long, les tokens précédant les 224 derniers seront ignorés.

Prise en charge des paramètres

• Le streaming n'est pas encore pris en charge pour les endpoints de transcription audio. L'ensemble de l'audio doit être envoyé et traité en une seule requête.

• Les formats de réponse srt et vtt ne sont pas encore pris en charge. Les formats de réponse disponibles sont listés ici.

Formats, durées et tailles audio pris en charge

Formats audio

L'API prend en charge plusieurs formats audio, mentionnés précédemment. Assurez-vous que votre fichier est dans un format pris en charge pour qu'il puisse être transcrit avec succès.

Limites de taille de fichier et de durée :

• Requêtes authentifiées (via une clé API) : jusqu'à 2048 Mo ou 10 800 secondes d'audio par requête.
• Requêtes anonymes : jusqu'à 10 Mo ou 60 secondes d'audio par requête.

Transcrire des fichiers audio volumineux

Si votre fichier audio dépasse ces limites, vous pouvez le découper en segments plus petits avant de l'envoyer à l'endpoint de transcription.

Évitez de découper en plein milieu d'une phrase, car cela peut entraîner une perte de contexte et réduire la précision de la transcription. L'utilisation de formats audio compressés peut également aider à réduire la taille du fichier.

Exemple

Découpage audio avec la bibliothèque Python open source pydub :

from pydub import AudioSegment
import math
import os

# Load the audio file
audio = AudioSegment.from_mp3("long_interview.mp3")

# Define chunk duration in milliseconds (e.g., 30 minutes)
chunk_duration = 30 * 60 * 1000  # 30 minutes

# Calculate how many chunks we need
num_chunks = math.ceil(len(audio) / chunk_duration)

# Ensure output folder exists
output_dir = "chunks"
os.makedirs(output_dir, exist_ok=True)

# Loop through and export each chunk
for i in range(num_chunks):
    start_time = i * chunk_duration
    end_time = min((i + 1) * chunk_duration, len(audio))
    chunk = audio[start_time:end_time]

    chunk_filename = os.path.join(output_dir, f"long_interview_part{i+1}.mp3")
    chunk.export(chunk_filename, format="mp3")
    print(f"Exported {chunk_filename}")

Répétez ce processus pour créer plusieurs segments, puis transcrivez chaque segment individuellement.

Conclusion

Dans ce guide, nous avons expliqué comment utiliser les modèles de transcription audio disponibles sur AI Endpoints. Nous avons fourni un aperçu complet de cette fonctionnalité qui peut vous aider à parfaire l'intégration du modèle dans votre propre application.

Aller plus loin

Parcourez la documentation AI Endpoints complète pour mieux comprendre les concepts principaux et démarrer.

Pour une formation ou une assistance technique sur la mise en œuvre de nos solutions, contactez votre commercial ou consultez la page Professional Services pour obtenir un devis et faire analyser votre projet par nos experts.

Votre avis nous intéresse !

N’hésitez pas à nous faire part de vos questions, retours et suggestions pour améliorer le service :

• Sur le serveur Discord OVHcloud