Utiliser la traduction de la parole en parole

Expérimental

Cette fonctionnalité est soumise(s) aux "Conditions des offres de pré-DG" de la section "Conditions générales du service" des Conditions spécifiques du service. Les fonctionnalités de pré-DG sont disponibles "en l'état" et peuvent avoir une prise en charge limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

La fonctionnalité de traduction de la parole utilise l'IA pour interpréter le langage, ce qui permet aux personnes et aux systèmes qui parlent des langues différentes de communiquer. Votre application peut utiliser cette fonctionnalité pour traiter un flux audio contenant de la parole dans une langue et le traduire en temps réel dans une autre langue.

Contrairement à d'autres fonctionnalités de l'API Live qui prennent en charge les conversations au tour par tour, la traduction de la parole en parole traite en continu les entrées audio et diffuse les sorties suivantes à mesure qu'elles sont disponibles :

• Transcription : texte reconnu à partir du flux audio d'entrée dans la langue d'origine.
• Traduction : texte traduit dans la langue cible.
• Audio synthétisé : flux audio du texte traduit prononcé dans la langue cible avec la voix du locuteur d'origine.

Modèles compatibles

Vous pouvez utiliser la traduction de la parole à la parole avec le modèle suivant :

Version de modèle	Niveau de disponibilité
gemini-2.5-flash-s2st-exp-11-2025	Expérimental privé

Remarque : Le modèle gemini-2.5-flash-s2st-exp-11-2025 n'est compatible qu'avec la traduction de la parole en parole. Il n'est pas compatible avec les autres fonctionnalités de l'API Live, comme l'audio proactif.

Exigences concernant l'audio d'entrée

La traduction de la parole en parole n'accepte que les entrées audio. Pour en savoir plus sur les formats audio, les codecs et les spécifications acceptés, comme le taux d'échantillonnage, consultez Formats audio acceptés.

Utiliser la traduction vocale

Pour utiliser la traduction de la parole à la parole, consultez les exemples de code suivants :

Python

# Set language_code to your desired language, in this case, Mandarin Chinese.
speech_config = SpeechConfig(language_code="cmn")

config = LiveConnectConfig(
    response_modalities=["AUDIO"],
    speech_config=speech_config,
    input_audio_transcription=input_transcription,
    output_audio_transcription=output_transcription,
)

audio_file = Part.from_uri(file_uri=audio_url, mime_type="audio/mpeg")
contents = [audio_file]

response = client.models.generate_content(model=MODEL_ID, contents=contents)
display(Markdown(response.text))

Python

import asyncio

# Set model generation_config
CONFIG = {
    "response_modalities": ["AUDIO"],
    "speech_config": {
        "language_code": "cmn",
    },
}

headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {bearer_token[0]}",
}

# Connect to the server
async with connect(SERVICE_URL, additional_headers=headers) as ws:
    # Setup the session
    await ws.send(
        json.dumps(
            {
                "setup": {
                    "model": MODEL,
                    "generation_config": CONFIG,
                    "input_audio_transcription": {},
                    "output_audio_transcription": {},
                    "enable_speech_to_speech_translation": True,
                }
            }
        )
    )

    # Receive setup response
    raw_response = await ws.recv(decode=False)
    setup_response = json.loads(raw_response.decode("ascii"))
    print(setup_response)

    msg = {
        "realtime_input": {
            "audio": {
                "mime_type": "audio/pcm",
                "data": base64.b64encode(wav_data).decode('utf-8'),
            }
        }
    }

    await ws.send(json.dumps(msg))

    overall_responses = []
    timeout_seconds = 10 # Set timeout to 3 seconds

    # Receive chucks of server response with a timeout
    try:
        while True:
            try:
                raw_response = await asyncio.wait_for(ws.recv(decode=False), timeout_seconds)
                response = json.loads(raw_response.decode())
                server_content = response.pop("serverContent", None)
                if server_content is None:
                    break

                # Input Transcription.
                input_transcription = server_content.pop("inputTranscription", None)
                if input_transcription is not None:
                  raw_text = input_transcription.pop("text", None)
                  if raw_text is not None:
                    display(Markdown(f"**Input >** {raw_text}"))

                # Output Transcription.
                output_transcription = server_content.pop("outputTranscription", None)
                if output_transcription is not None:
                  raw_text = output_transcription.pop("text", None)
                  if raw_text is not None:
                    display(Markdown(f"**Response >** {raw_text}"))

                model_turn = server_content.pop("modelTurn", None)
                if model_turn is not None:
                    parts = model_turn.pop("parts", None)
                    if parts is not None:
                        for part in parts:
                            pcm_data = base64.b64decode(part["inlineData"]["data"])
                            overall_responses.append(np.frombuffer(pcm_data, dtype=np.int16))

                # End of turn
                # turn_complete = server_content.pop("turnComplete", None)
                # if turn_complete:
                #     break
            except asyncio.TimeoutError:
                print(f"Timeout: No response received from the websocket within {timeout_seconds} seconds.")
                if overall_responses:
                  display(Audio(np.concatenate(overall_responses), rate=24000, autoplay=True))
                break # Exit the loop on timeout
            except websockets.exceptions.ConnectionClosed as e:
              print(f"Connection closed by exception, code: {e.code}, reason: {e.reason}")
              if overall_responses:
                display(Audio(np.concatenate(overall_responses), rate=24000, autoplay=True))
              break # Exit the loop on connection closed
            except Exception as e:
              print(f"An unexpected error occurred: {e}")
              if overall_responses:
                display(Audio(np.concatenate(overall_responses), rate=24000, autoplay=True))
              break # Exit the loop on other exceptions

    finally:
        try:
          await ws.close(code=1000, reason="Normal closure") #example close
        except websockets.exceptions.ConnectionClosed as e:
          print(f"Connection closed by exception, code: {e.code}, reason: {e.reason}")
        except Exception as e:
          print(f"An unexpected error occurred: {e}")

Langues disponibles

Code de langue	Langue
aa	Afar
ab	Abkhaze
ace	Achénais
ach	acoli
af	Afrikaans
ak	Akan
alz	Alur
a.m.	Amharique
une	Aragonais
ar	Arabe
as	Assamais
av	Avaric
awa	Awadhi
ay	Aymara
az	Azéri
ba	Bachkir
bal	Baloutchi
ban	Balinais
bbc	Batak Toba
bci	Baoulé
b	Biélorusse
bem	Bemba
ber	Berbère
bew	Betawi
bg	Bulgare
bgc	Haryanvi
bho	Bhodjpouri
bi	Bislama
bm	Bambara
bn	Bengalî
bo	Tibétain
br	Breton
bs	Bosniaque
bts	Batak Simalungun
btx	Batak Karo
ca	Catalan
ce	Tchétchène
ceb	Cebuano
cgg	Chiga
ch	Chamorro
chk	Chuuk
cmn	Chinois mandarin
cnh	Hakha Chin
co	Corse
cr	Cri
crh	Tatar de Crimée
crs	Créole seychellois
cs	Tchèque
cv	Tchouvache
cy	Gallois
da	Danois
de	Allemand
din	Dinka
doi	Dogri
dov	Dombe
dv	Divehi
dyu	Dioula
dz	Dzongkha
ee	Éwé
el	Grec
en	Anglais
eo	Espéranto
es	Espagnol
et	Estonien
eu	Basque
fa	Persan
ff	Peul
fi	Finnois
fil	Philippin
fj	Fidjien
fo	Féroïen
fon	Fon
fr	Français
fourrure	Frioulan
fy	Frison occidental
dg	Irlandais
gaa	Ga
gd	Gaélique
gl	Galicien
gn	Guarani
gu	Gujarati
gv	Manx
ha	Haoussa
haw	Hawaïen
il	Hébreu
salut	Hindi
hil	Hiligaïnon
hmn	Hmong
ho	Hiri motou
h	Croate
hrx	Hunsrik
ht	Créole haïtien
hu	Hongrois
hy	Arménien
hz	Héréro
iba	Iban
id	Indonésien
ig	Igbo
ilo	Ilocano
est	Islandais
pour les recevoir.	Italien
iu	Inuktitut
ja	Japonais
Jam	Créole anglais jamaïcain
jv	Javanais
ka	Géorgien
kac	Kachin
kek	Q'eqchi'
kg	Kongo
kha	Khasi
ki	Kikuyu
kj	Kuanyama
kk	Kazakh
kl	Groenlandais
km	Khmer central
kn	Kannara
ko	Coréen
kok	Konkani
kr	Kanuri
kri	Krio
ks	Cachemiri
ktu	Kituba
ku	Kurde
kv	Komi
kw	Cornish
ky	Kirghyz
la	Latin
lb	Luxembourgeois
lg	Ganda
li	Limbourgeois
lij	Ligure
lmo	Lombard
ln	Lingala
lo	Laotien
lt	Lituanien
lu	Luba-katanga
lua	luba-lulua
Luo	Dholuo
lus	Mizo
lv	Letton
mad	Madurais
mai	Maithili
mak	Makasar
mam	Mam
mfe	créole mauricien
mg	Malgache
mh	Marshallais
min	Minangkabau
mk	Macédonien
ml	Malayalam
mn	Mongol
mr	Marathi
ms	Malaisien
mt	Maltais
mwr	Marwari
my	Birman
N/A	Nauru
nb	norvégien bokmål
nd	Ndébélé du Nord
ndc	Ndau
ne	Népalais
nouveau	Newari
ng	Ndonga
nhe	Nahuatl oriental huastèque
nl	Néerlandais
nn	Nynorsk (norvégien)
nr	Ndébélé du Sud
nso	Pedi
nus	Nuer
nv	Navajo
ny	Chewa
oc	Occitan
oj	Ojibwa
om	Oromo
ou	Oriya
os	Ossète
pa	Panjabi
pag	Pangasinan
pam	Pampanga
pap	Papiamento
pl	Polonais
ps	Pachtô
pt	Portugais
qu	Quechua
rm	Romanche
rn	Roundi
ro	Roumain
ru	Russe
rw	Kinyarwanda
sa	Sanskrit
sah	Yakut
Sam	Santali
sc	Sarde
scn	Sicilien
sd	Sindhî
se	Same du Nord
sg	Sango
shn	Shan
si	Cingalais
sk	Slovaque
sl	Slovène
sm	Samoan
sn	Shona
so	Somali
sq	Albanais
sr	Serbe
ss	Swati
st	Sotho du Sud
su	Soundanais
sv	Suédois
sw	Swahili
szl	Silésien
ta	Tamoul
tcy	Toulou
te	Télougou
tet	Tetum
tg	Tadjik
th	Thaï
ti	Tigrinya
tiv	Tiv
tk	Turkmène
tl	Tagalog
tn	Tswana
à	Tonga
tpi	Tok pisin
tr	Turc
trp	Kok Borok
ts	Tsonga
tt	Tatar
tum	Tumbuka
tw	Twi
ty	Tahitien
tyv	Touvain
udm	Oudmourte
ug	Ouïghour
uk	Ukrainien
ur	Urdu
uz	Ouzbek
ve	Venda
vec	Vénitien
vi	Vietnamien
wa	Wallon
guerre	Waray-waray
wo	Wolof
xh	Xhosa
yi	Yiddish
yo	Yoruba
yua	Maya yucatèque
yue	Cantonais
za	Zhuang
zh	Chinois
zu	Zulu

Facturation

Comme il s'agit d'une fonctionnalité expérimentale, l'utilisation de la traduction de la parole en parole ne vous sera pas facturée.

Pour en savoir plus sur les tarifs et la facturation, consultez les tarifs de Vertex AI.