ऑडियो को टेक्स्ट में बदलना

Gemini API, ऑडियो फ़ाइलों में मौजूद बोली को टेक्स्ट में बदलता है. इसके लिए, Gemini 3.5 Transcribe मॉडल (gemini-3.5-transcribe) का इस्तेमाल किया जाता है. Gemini की ऑडियो समझने की क्षमताओं के आधार पर, यह सटीक ट्रांसक्रिप्शन देता है. इसमें भाषा की पहचान अपने-आप होती है, बोलने वाले की पहचान होती है, शब्द-लेवल के टाइमस्टैंप होते हैं, और कस्टम शब्दावली के बारे में सुझाव मिलते हैं. इसमें स्मार्ट ट्रांसक्रिप्शन मोड भी मिलता है. इसमें शब्दों को सही तरीके से व्यवस्थित करने और फ़ॉर्मैट करने की सुविधा होती है.

किसी ऑडियो फ़ाइल को ट्रांसक्राइब करने के लिए, ऑडियो अपलोड करें और उसे gemini-3.5-transcribe पर भेजें:

Python

from google import genai

client = genai.Client()

audio_file = client.files.upload(file="path/to/sample.mp3")

interaction = client.interactions.create(
    model="gemini-3.5-transcribe",
    input=[
        {
            "type": "audio",
            "uri": audio_file.uri,
            "mime_type": audio_file.mime_type,
        }
    ],
)

print(interaction.output_text)

JavaScript

import { GoogleGenAI } from "@google/genai";

const client = new GoogleGenAI({});

const audioFile = await client.files.upload({
  file: "path/to/sample.mp3",
  config: { mime_type: "audio/mp3" },
});

const interaction = await client.interactions.create({
  model: "gemini-3.5-transcribe",
  input: [
    {
      type: "audio",
      uri: audioFile.uri,
      mime_type: audioFile.mimeType,
    },
  ],
});

console.log(interaction.output_text);

REST

# First upload the file via the Files API, then pass its URI:
curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3.5-transcribe",
    "input": [
      {
        "type": "audio",
        "uri": "YOUR_FILE_URI",
        "mime_type": "audio/mp3"
      }
    ]
  }'

खास जानकारी

Gemini 3.5 Transcribe को, बोली को लिखाई में बदलने के टास्क के लिए ऑप्टिमाइज़ किया गया है. यह अलग-अलग लहज़ों, बैकग्राउंड के शोर, और कई भाषाओं में की गई बातचीत को समझ सकता है.

मुख्य सुविधाओं में ये शामिल हैं:

  • अपने-आप बोली की पहचान करने की सुविधा (एएसआर): यह 85 से ज़्यादा स्थानीय भाषाओं की पहचान अपने-आप करती है. यह सुविधा, मैन्युअल कॉन्फ़िगरेशन के बिना, एक वाक्य में और एक से ज़्यादा वाक्यों में कोड-स्विचिंग को मैनेज करती है.
  • कस्टम शब्दावली: इसमें 1,000 वाक्यांशों को पास करके, डोमेन के हिसाब से शब्दों, छोटे नामों, और सही नामों को पहचानने की सुविधा को बेहतर बनाया जाता है.
  • स्पीकर डायराइज़ेशन: यह सुविधा, एक से ज़्यादा लोगों की आवाज़ में अंतर करती है. साथ ही, बोले गए सेगमेंट को अलग-अलग लेबल असाइन करती है.
  • शब्द-स्तर के टाइमस्टैंप: इससे पहचाने गए हर शब्द के शुरू और खत्म होने के समय के सटीक ऑफ़सेट जनरेट होते हैं.
  • स्मार्ट ट्रांसक्रिप्शन: यह सुविधा, बोलने में होने वाली रुकावटों, फ़िलर शब्दों, और दोहराव को हटा देती है. साथ ही, टेक्स्ट को व्यवस्थित फ़ॉर्मैट में बदल देती है.
  • फ़ॉर्मैट करना और सामान्य बनाना: इसमें कैपिटल लेटर, विराम चिह्न, और टेक्स्ट को सामान्य बनाने की प्रोसेस शामिल है. जैसे, "2 करोड़ 60 लाख डॉलर" को "2.6 करोड़ डॉलर" में बदलना.

ऑडियो कॉन्टेंट के आधार पर तर्क देने या सवालों के जवाब देने के लिए, ऑडियो समझने की सुविधा का इस्तेमाल करें. टेक्स्ट-टू-स्पीच ऑडियो सिंथेसिस के लिए, टेक्स्ट-टू-स्पीच का इस्तेमाल करें.

भाषा का पता लगाना और सुझाव पाना

डिफ़ॉल्ट रूप से, मॉडल बोली जा रही भाषा का पता अपने-आप लगाता है. यह सुविधा, बोलने वालों के कोड-स्विच करने पर, भाषाओं के बीच डाइनैमिक तरीके से स्विच करती है.

अपने-आप पहचान होने की सुविधा का इस्तेमाल करने के लिए, language_codes को शामिल न करें या खाली सूची दें:

Python

interaction = client.interactions.create(
    model="gemini-3.5-transcribe",
    input=[
        {
            "type": "audio",
            "uri": audio_file.uri,
            "mime_type": audio_file.mime_type,
        }
    ],
    generation_config={
        "transcription_config": {
            "language_codes": [],
        }
    },
)

JavaScript

const interaction = await client.interactions.create({
  model: "gemini-3.5-transcribe",
  input: [
    {
      type: "audio",
      uri: audioFile.uri,
      mime_type: audioFile.mimeType,
    },
  ],
  generation_config: {
    transcription_config: {
      language_codes: [],
    },
  },
});

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3.5-transcribe",
    "input": [
      {
        "type": "audio",
        "uri": "YOUR_FILE_URI",
        "mime_type": "audio/mp3"
      }
    ],
    "generation_config": {
      "transcription_config": {
        "language_codes": []
      }
    }
  }'

अगर आपको भाषा के बारे में पहले से पता है, तो ट्रांसक्रिप्शन की सटीकता को बेहतर बनाने के लिए, language_codes में BCP-47 भाषा कोड डालें. इसके लिए, इस्तेमाल की जा सकने वाली भाषाएं देखें:

Python

generation_config = {
    "transcription_config": {
        "language_codes": ["es-ES"],
    }
}

JavaScript

const generationConfig = {
  transcription_config: {
    language_codes: ["es-ES"],
  },
};

REST

{
  "generation_config": {
    "transcription_config": {
      "language_codes": ["es-ES"]
    }
  }
}

कस्टम शब्दावली

स्पीच मॉडल को असामान्य शब्दों, तकनीकी शब्दों, ब्रैंड के नामों या व्यक्तिवाचक संज्ञाओं के बारे में बताया जा सकता है. custom_vocabulary ऐरे में ज़्यादा से ज़्यादा 1,000 शब्द डालें. आम तौर पर, 100 शब्दों तक डालने पर सबसे अच्छे नतीजे मिलते हैं:

Python

interaction = client.interactions.create(
    model="gemini-3.5-transcribe",
    input=[
        {
            "type": "audio",
            "uri": audio_file.uri,
            "mime_type": audio_file.mime_type,
        }
    ],
    generation_config={
        "transcription_config": {
            "custom_vocabulary": ["Gemini", "Kubernetes", "BigQuery"],
        }
    },
)

JavaScript

const interaction = await client.interactions.create({
  model: "gemini-3.5-transcribe",
  input: [
    {
      type: "audio",
      uri: audioFile.uri,
      mime_type: audioFile.mimeType,
    },
  ],
  generation_config: {
    transcription_config: {
      custom_vocabulary: ["Gemini", "Kubernetes", "BigQuery"],
    },
  },
});

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3.5-transcribe",
    "input": [
      {
        "type": "audio",
        "uri": "YOUR_FILE_URI",
        "mime_type": "audio/mp3"
      }
    ],
    "generation_config": {
      "transcription_config": {
        "custom_vocabulary": ["Gemini", "Kubernetes", "BigQuery"]
      }
    }
  }'

स्पीकर डायराइज़ेशन

स्पीकर डायराइज़ेशन की सुविधा, रिकॉर्डिंग में मौजूद अलग-अलग आवाज़ों की पहचान करती है. साथ ही, हर सेगमेंट को स्पीकर आइडेंटिफ़ायर के साथ टैग करती है. जैसे, spk_1 या spk_2. इसमें ज़्यादा से ज़्यादा आठ स्पीकर इस्तेमाल किए जा सकते हैं. हालांकि, तीन या उससे ज़्यादा स्पीकर के लिए एट्रिब्यूशन की सुविधा, अब भी एक्सपेरिमेंट के तौर पर उपलब्ध है.

mode में diarization_mode को कॉन्फ़िगर करके, डायराइज़ेशन की सुविधा चालू करें:

Python

interaction = client.interactions.create(
    model="gemini-3.5-transcribe",
    input=[
        {
            "type": "audio",
            "uri": audio_file.uri,
            "mime_type": audio_file.mime_type,
        }
    ],
    generation_config={
        "transcription_config": {
            "mode": {
                "type": "verbatim",
                "diarization_mode": "speaker",
            },
        }
    },
)

JavaScript

const interaction = await client.interactions.create({
  model: "gemini-3.5-transcribe",
  input: [
    {
      type: "audio",
      uri: audioFile.uri,
      mime_type: audioFile.mimeType,
    },
  ],
  generation_config: {
    transcription_config: {
      mode: {
        type: "verbatim",
        diarization_mode: "speaker",
      },
    },
  },
});

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3.5-transcribe",
    "input": [
      {
        "type": "audio",
        "uri": "YOUR_FILE_URI",
        "mime_type": "audio/mp3"
      }
    ],
    "generation_config": {
      "transcription_config": {
        "mode": {
          "type": "verbatim",
          "diarization_mode": "speaker"
        }
      }
    }
  }'

शब्दों के लेवल पर टाइमस्टैंप

शब्द-लेवल के टाइमस्टैंप से, ऑडियो स्ट्रीम में पहचाने गए हर शब्द के शुरू और खत्म होने के सटीक ऑफ़सेट मिलते हैं.

mode में जाकर timestamp_granularities को कॉन्फ़िगर करके, टाइमस्टैंप की सुविधा चालू करें:

Python

interaction = client.interactions.create(
    model="gemini-3.5-transcribe",
    input=[
        {
            "type": "audio",
            "uri": audio_file.uri,
            "mime_type": audio_file.mime_type,
        }
    ],
    generation_config={
        "transcription_config": {
            "mode": {
                "type": "verbatim",
                "timestamp_granularities": ["word"],
            },
        }
    },
)

JavaScript

const interaction = await client.interactions.create({
  model: "gemini-3.5-transcribe",
  input: [
    {
      type: "audio",
      uri: audioFile.uri,
      mime_type: audioFile.mimeType,
    },
  ],
  generation_config: {
    transcription_config: {
      mode: {
        type: "verbatim",
        timestamp_granularities: ["word"],
      },
    },
  },
});

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3.5-transcribe",
    "input": [
      {
        "type": "audio",
        "uri": "YOUR_FILE_URI",
        "mime_type": "audio/mp3"
      }
    ],
    "generation_config": {
      "transcription_config": {
        "mode": {
          "type": "verbatim",
          "timestamp_granularities": ["word"]
        }
      }
    }
  }'

स्पीकर लेबल और शब्द के टाइमस्टैंप, दोनों पाने के लिए mode में diarization_mode और timestamp_granularities को एक साथ इस्तेमाल किया जा सकता है:

Python

generation_config = {
    "transcription_config": {
        "custom_vocabulary": ["Gemini"],
        "mode": {
            "type": "verbatim",
            "diarization_mode": "speaker",
            "timestamp_granularities": ["word"],
        },
    }
}

JavaScript

const generationConfig = {
  transcription_config: {
    custom_vocabulary: ["Gemini"],
    mode: {
      type: "verbatim",
      diarization_mode: "speaker",
      timestamp_granularities: ["word"],
    },
  },
};

REST

{
  "generation_config": {
    "transcription_config": {
      "custom_vocabulary": ["Gemini"],
      "mode": {
        "type": "verbatim",
        "diarization_mode": "speaker",
        "timestamp_granularities": ["word"]
      }
    }
  }
}

ट्रांसक्रिप्शन मोड

Gemini 3.5 Transcribe, mode पैरामीटर के ज़रिए ट्रांसक्रिप्शन के दो मोड सपोर्ट करता है:

  • verbatim (डिफ़ॉल्ट): इसमें बोले गए हर शब्द का सटीक ट्रांसक्रिप्ट मिलता है. इसमें फ़िलर शब्दों ("अम", "अह", "जैसे", "आपको पता है"), दोहराव, ठहराव, और गलत शुरुआत को भी शामिल किया जाता है. इस मोड ({"type": "verbatim", ...}) में, टाइमस्टैंप और स्पीकर डायराइज़ेशन की सुविधा कॉन्फ़िगर की जाती है.
  • smart (स्मार्ट ट्रांसक्रिप्शन): यह सुविधा, ट्रांसक्रिप्ट को पढ़ने के लिए ऑप्टिमाइज़ करती है. इसके लिए, यह पोस्ट-प्रोसेसिंग की बेहतर तकनीक का इस्तेमाल करती है:
    • अस्पष्टता हटाना: बातचीत में फ़िलर शब्दों, स्टट्रिंग, और गलत शुरुआत को हटाता है.
    • बोलते समय की गई गलतियों को ठीक करना: सीधे तौर पर बोली गई गलतियों को ठीक करता है. उदाहरण के लिए, "चलो मंगलवार को मिलते हैं, नहीं नहीं, बुधवार को दो बजे" को "चलो बुधवार को दोपहर दो बजे मिलते हैं" में बदल देता है.
    • स्ट्रक्चर्ड फ़ॉर्मैटिंग अपने-आप होने की सुविधा: यह सुविधा, बोले गए शब्दों को पैराग्राफ़, नंबर वाली सूचियों, बुलेट पॉइंट, फ़ॉर्मैट की गई तारीखों, मुद्राओं, और संख्याओं में अपने-आप व्यवस्थित करती है.
    • व्याकरण से जुड़ी गड़बड़ियां ठीक करना: इसमें विराम चिह्न, वाक्य के पहले अक्षर को कैपिटल करना, और फ़्लो को नैचुरल तरीके से सेट करना शामिल है.
ऑडियो कॉन्टेंट verbatim आउटपुट smart (स्मार्ट ट्रांसक्रिप्शन) आउटपुट
"अरे, तो मीटिंग के लिए, मुझे लगता है कि हमें, अह, ऐलिस को न्योता देना चाहिए और, नहीं, बॉब और कैरल को न्योता देना चाहिए." "अम तो मीटिंग के लिए, मुझे लगता है कि हमें एलिस को न्योता देना चाहिए और रुको, नहीं बॉब और कैरल को न्योता देना चाहिए." "मीटिंग के लिए, हमें बॉब और कैरल को न्योता भेजना चाहिए."
"पहले आइटम की समीक्षा करो, दूसरे आइटम के लिए बजट तय करो, तीसरे आइटम के लिए समयसीमा तय करो, और रीकैप भेजो" "first item review budget second item finalize timeline third item send recap" "1. बजट की समीक्षा करें
2. टाइमलाइन को फ़ाइनल करें
3. रीकैप भेजो"

Python

interaction = client.interactions.create(
    model="gemini-3.5-transcribe",
    input=[
        {
            "type": "audio",
            "uri": audio_file.uri,
            "mime_type": audio_file.mime_type,
        }
    ],
    generation_config={
        "transcription_config": {
            "mode": "smart",
        }
    },
)
print(interaction.output_text)

JavaScript

const interaction = await client.interactions.create({
  model: "gemini-3.5-transcribe",
  input: [
    {
      type: "audio",
      uri: audioFile.uri,
      mime_type: audioFile.mimeType,
    },
  ],
  generation_config: {
    transcription_config: {
      mode: "smart",
    },
  },
});
console.log(interaction.output_text);

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3.5-transcribe",
    "input": [
      {
        "type": "audio",
        "uri": "YOUR_FILE_URI",
        "mime_type": "audio/mp3"
      }
    ],
    "generation_config": {
      "transcription_config": {
        "mode": "smart"
      }
    }
  }'

ट्रांसक्रिप्शन आउटपुट को पार्स किया जा रहा है

पूरी ट्रांसक्रिप्ट का टेक्स्ट interaction.output_text में दिखता है.

timestamp_granularities या diarization_mode चालू होने पर, एपीआई इंटरैक्शन कॉन्टेंट से जुड़े शब्द-लेवल के एनोटेशन की जानकारी भी दिखाता है.

शब्दों के टाइमस्टैंप और बोलने वाले की बारी की जानकारी निकालने और उसे दोहराने का तरीका यहां बताया गया है:

Python

def extract_word_annotations(interaction):
    words = []
    for step in getattr(interaction, "steps", []) or []:
        for content in getattr(step, "content", []) or []:
            for annotation in getattr(content, "annotations", []) or []:
                if getattr(annotation, "type", None) == "word_info":
                    words.append(annotation)
    return words

words = extract_word_annotations(interaction)

for w in words:
    speaker = f"[{w.speaker}] " if getattr(w, "speaker", None) else ""
    start = getattr(w, "start_offset", "")
    end = getattr(w, "end_offset", "")
    timing = f"({start} -> {end}) " if start and end else ""
    print(f"{speaker}{timing}{w.text}")

JavaScript

function extractWordAnnotations(interaction) {
  const words = [];
  for (const step of interaction.steps ?? []) {
    for (const content of step.content ?? []) {
      for (const annotation of content.annotations ?? []) {
        if (annotation.type === "word_info") {
          words.push(annotation);
        }
      }
    }
  }
  return words;
}

const words = extractWordAnnotations(interaction);

for (const w of words) {
  const speaker = w.speaker ? `[${w.speaker}] ` : "";
  const timing = (w.start_offset && w.end_offset) ? `(${w.start_offset} -> ${w.end_offset}) ` : "";
  console.log(`${speaker}${timing}${w.text}`);
}

REST

{
  "id": "interactions/abc123xyz",
  "status": "completed",
  "steps": [
    {
      "id": "step_001",
      "type": "model_output",
      "content": [
        {
          "type": "text",
          "text": "Hello world",
          "annotations": [
            {
              "type": "word_info",
              "text": "Hello",
              "speaker": "spk_1",
              "start_offset": "0.100s",
              "end_offset": "0.450s"
            },
            {
              "type": "word_info",
              "text": "world",
              "speaker": "spk_1",
              "start_offset": "0.500s",
              "end_offset": "0.850s"
            }
          ]
        }
      ]
    }
  ]
}

इस्तेमाल की जा सकने वाली भाषाएं

Gemini 3.5 Transcribe के लिए, यहाँ दी गई भाषाएँ और BCP-47 भाषा कोड इस्तेमाल किए जा सकते हैं:

भाषा BCP-47 कोड भाषा BCP-47 कोड
अफ़्रीकान्स af-ZA जापानी ja-JP
अमहैरिक am-ET जावानीज़ jv-ID
अरबी (मिस्र) ar-EG Kabuverdianu kea-CV
आर्मीनियन hy-AM कन्नड़ kn-IN
असमिया as-IN कज़ाक kk-KZ
अज़रबैजानी az-AZ कोरियन ko-KR
बेलारूसी be-BY किर्गिज़ ky-KG
बांग्ला (बांग्लादेश) bn-BD लातवियन lv-LV
बांग्ला (भारत) bn-IN लिंगाला ln-CD
बोस्नियन bs-BA लिथुएनियन lt-LT
बल्गैरियन bg-BG मैसेडोनियन mk-MK
बल्गेरियन (ऐरोमेनियन) rup-BG मलय ms-MY
बर्मीज़ my-MM मलयालम ml-IN
कैंटनीज़ (ट्रेडिशनल) yue-Hant-HK मोल्टीज़ mt-MT
कैटलैन ca-ES मैंडरिन चाइनीज़ (सिंप्लिफ़ाइड) cmn-Hans-CN
सेबुआनो ceb मराठी mr-IN
सेंट्रल खमेर km-KH मंगोलियन mn-MN
क्रोएशियन hr-HR नेपाली ne-NP
चेक cs-CZ नॉर्वीजन nb-NO
डैनिश da-DK ओड़िया or-IN
डच nl-NL पोलिश pl-PL
अंग्रेज़ी (ग्रेट ब्रिटेन) en-GB पॉर्चुगीज़ (ब्राज़ील) pt-BR
अंग्रेज़ी (भारत) en-IN पॉर्चगीज़ (पुर्तगाल) pt-PT
अंग्रेज़ी (संयुक्त राज्य अमेरिका) en-US पंजाबी pa-IN
एस्टोनियन et-EE पंजाबी (गुरमुखी लिपि) pa-Guru-IN
फ़ारसी fa-IR रोमानियन ro-RO
फ़िलिपीनी fil-PH रूसी ru-RU
फ़िनिश fi-FI सर्बियन sr-RS
फ़्रांसीसी fr-FR सिंधी (अरबी लिपि) sd-Arab-IN
गैलिशियन gl-ES स्लोवाक sk-SK
जॉर्जियन ka-GE स्लोवेनियन sl-SI
जर्मन de-DE स्पैनिश (लैटिन अमेरिका) es-419
ग्रीक el-GR स्पैनिश (संयुक्त राज्य अमेरिका) es-US
गुजराती gu-IN स्वाहिली (केन्या) sw-KE
हौसा ha-NG स्वीडिश sv-SE
हिब्रू he-IL ताजिक tg-TJ
हिन्दी hi-IN तेलुगु te-IN
हंगेरियन hu-HU थाई th-TH
आइसलैंडिक is-IS टर्किश tr-TR
इंडियन इंग्लिश en-IN यूक्रेनियन uk-UA
इंडोनेशियन id-ID उज़्बेक uz-UZ
इटैलियन it-IT वियतनामीज़ vi-VN

पैरामीटर का रेफ़रंस

generation_config में मौजूद transcription_config ऑब्जेक्ट में फ़ील्ड सेट करके, ट्रांसक्रिप्शन की सुविधा कॉन्फ़िगर करें:

फ़ील्ड टाइप जानकारी
language_codes स्ट्रिंग का कलेक्शन BCP-47 भाषा कोड (जैसे, ["en-US"]). अगर इसे शामिल नहीं किया जाता है या यह खाली ([]) है, तो मॉडल अपने-आप भाषा का पता लगाता है और कोड-स्विचिंग को मैनेज करता है.
custom_vocabulary स्ट्रिंग का कलेक्शन ज़्यादा से ज़्यादा 1,000 कस्टम शब्द, संक्षिप्त नाम या व्यक्तिवाचक संज्ञाएं, ताकि बोली की पहचान करने की सुविधा को बेहतर बनाया जा सके.
mode ऑब्जेक्ट या स्ट्रिंग बोले जा रहे शब्दों को टेक्स्ट में बदलने की सुविधा कॉन्फ़िगर करना. यह "smart" या वर्बैटिम मोड ऑब्जेक्ट ({"type": "verbatim", ...}) स्वीकार करता है. डिफ़ॉल्ट रूप से, वर्बैटिम ट्रांसक्रिप्शन पर सेट होता है.
mode.type स्ट्रिंग (सिर्फ़ वर्बैटिम मोड के लिए) मोड आइडेंटिफ़ायर. यह हमेशा "verbatim" पर सेट होता है.
mode.timestamp_granularities स्ट्रिंग का कलेक्शन (सिर्फ़ वर्बैटिम मोड के लिए) जवाब में टाइमस्टैंप की जानकारी कितनी बार देनी है. शब्द की शुरुआत और खत्म होने के ऑफ़सेट चालू करने के लिए, ["word"] पास करें.
mode.diarization_mode स्ट्रिंग (सिर्फ़ वर्बैटिम मोड के लिए) डायराइज़ेशन मोड. अलग-अलग स्पीकर की पहचान करने और उन्हें लेबल करने के लिए, "speaker" पास करें.

सबसे सही तरीके

  • साफ़ ऑडियो दें: पक्का करें कि ऑडियो रिकॉर्डिंग में आवाज़ साफ़ सुनाई दे और उसमें कोई गड़बड़ी न हो.
  • ऑडियो की भाषा की जानकारी दें: अगर आपको ऑडियो की भाषा के बारे में पहले से पता है, तो language_codes का इस्तेमाल करें, ताकि ऑडियो को टेक्स्ट में ज़्यादा सटीक तरीके से बदला जा सके.
  • कस्टम शब्दावली को टारगेट करना: custom_vocabulary में रोज़मर्रा के आम शब्दों के बजाय, सिर्फ़ अलग-अलग डोमेन टर्म, ब्रैंड के नाम या संज्ञाएं शामिल करें.
  • ज़्यादा समय की रिकॉर्डिंग के लिए, Files API का इस्तेमाल करें: अगर फ़ाइल कुछ सेकंड से ज़्यादा लंबी है, तो client.files.upload का इस्तेमाल करके फ़ाइल अपलोड करें. साथ ही, मॉडल को वापस मिला फ़ाइल यूआरआई पास करें.

सीमाएं

  • ऑडियो की अवधि: स्टैंडर्ड यूनरी अनुरोधों में, एक घंटे तक की ऑडियो फ़ाइलें इस्तेमाल की जा सकती हैं. स्पीकर के हिसाब से लेबलिंग या शब्द-लेवल के टाइमस्टैंप जैसी सुविधाएं चालू होने पर, ऑडियो प्रोसेसिंग सिर्फ़ 30 मिनट तक की जा सकती है.
  • शब्द के लेवल पर टाइमस्टैंप: शब्द के लेवल पर टाइमस्टैंप की सुविधा चालू करने से, ट्रांसक्रिप्शन की कुल सटीकता कम हो सकती है.
  • स्पीकर डायराइज़ेशन: स्पीकर डायराइज़ेशन की सुविधा, आठ स्पीकर तक काम करती है. तीन या इससे ज़्यादा स्पीकर के लिए, स्पीकर एट्रिब्यूशन की सुविधा अभी एक्सपेरिमेंट के तौर पर उपलब्ध है.
  • कस्टम शब्दावली: custom_vocabulary में ज़्यादा से ज़्यादा 1,000 शब्द जोड़े जा सकते हैं. हालांकि, आम तौर पर 100 शब्दों से ही सबसे अच्छे नतीजे मिलते हैं.
  • मोड के साथ काम करने की सुविधा: स्मार्ट ट्रांसक्रिप्शन ("smart") को timestamp_granularities या diarization_mode के साथ इस्तेमाल नहीं किया जा सकता.

आगे क्या करना है