Kuptimi audio

Binjakët mund të analizojnë dhe kuptojnë hyrjen audio, duke mundësuar raste të përdorimit si më poshtë:

  • Përshkruani, përmblidhni ose përgjigjuni pyetjeve në lidhje me përmbajtjen audio.
  • Jepni një transkriptim të audios.
  • Analizoni segmente specifike të audios.

Ky udhëzues ju tregon se si të përdorni Gemini API për të gjeneruar një përgjigje teksti në hyrjen audio.

Para se të filloni

Përpara se të telefononi Gemini API, sigurohuni që keni të instaluar SDK-në tuaj të zgjedhur dhe një çelës Gemini API të konfiguruar dhe gati për t'u përdorur.

Futja e audios

Ju mund t'i siguroni të dhëna audio Binjakëve në mënyrat e mëposhtme:

Ngarko një skedar audio

Ju mund të përdorni Files API për të ngarkuar një skedar audio. Përdorni gjithmonë API-në e skedarëve kur madhësia totale e kërkesës (përfshirë skedarët, kërkesën për tekst, udhëzimet e sistemit, etj.) është më e madhe se 20 MB.

Kodi i mëposhtëm ngarkon një skedar audio dhe më pas përdor skedarin në një thirrje për generateContent .

Python JavaScript Shkoni PUSHIMI 
from google import genai

client = genai.Client(api_key="GOOGLE_API_KEY")

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

response = client.models.generate_content(
    model="gemini-2.0-flash", contents=["Describe this audio clip", myfile]
)

print(response.text)

import {
  GoogleGenAI,
  createUserContent,
  createPartFromUri,
} from "@google/genai";

const ai = new GoogleGenAI({ apiKey: "GOOGLE_API_KEY" });

async function main() {
  const myfile = await ai.files.upload({
    file: "path/to/sample.mp3",
    config: { mimeType: "audio/mp3" },
  });

  const response = await ai.models.generateContent({
    model: "gemini-2.0-flash",
    contents: createUserContent([
      createPartFromUri(myfile.uri, myfile.mimeType),
      "Describe this audio clip",
    ]),
  });
  console.log(response.text);
}

await main();

file, err := client.UploadFileFromPath(ctx, "path/to/sample.mp3", nil)
if err != nil {
    log.Fatal(err)
}
defer client.DeleteFile(ctx, file.Name)

model := client.GenerativeModel("gemini-2.0-flash")
resp, err := model.GenerateContent(ctx,
    genai.FileData{URI: file.URI},
    genai.Text("Describe this audio clip"))
if err != nil {
    log.Fatal(err)
}

printResponse(resp)

AUDIO_PATH="path/to/sample.mp3"
MIME_TYPE=$(file -b --mime-type "${AUDIO_PATH}")
NUM_BYTES=$(wc -c < "${AUDIO_PATH}")
DISPLAY_NAME=AUDIO

tmp_header_file=upload-header.tmp

# Initial resumable request defining metadata.
# The upload url is in the response headers dump them to a file.
curl "https://generativelanguage.googleapis.com/upload/v1beta/files?key=${GOOGLE_API_KEY}" \
  -D upload-header.tmp \
  -H "X-Goog-Upload-Protocol: resumable" \
  -H "X-Goog-Upload-Command: start" \
  -H "X-Goog-Upload-Header-Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Header-Content-Type: ${MIME_TYPE}" \
  -H "Content-Type: application/json" \
  -d "{'file': {'display_name': '${DISPLAY_NAME}'}}" 2> /dev/null

upload_url=$(grep -i "x-goog-upload-url: " "${tmp_header_file}" | cut -d" " -f2 | tr -d "\r")
rm "${tmp_header_file}"

# Upload the actual bytes.
curl "${upload_url}" \
  -H "Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Offset: 0" \
  -H "X-Goog-Upload-Command: upload, finalize" \
  --data-binary "@${AUDIO_PATH}" 2> /dev/null > file_info.json

file_uri=$(jq ".file.uri" file_info.json)
echo file_uri=$file_uri

# Now generate content using that file
curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GOOGLE_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[
          {"text": "Describe this audio clip"},
          {"file_data":{"mime_type": "${MIME_TYPE}", "file_uri": '$file_uri'}}]
        }]
      }' 2> /dev/null > response.json

cat response.json
echo

jq ".candidates[].content.parts[].text" response.json

Për të mësuar më shumë rreth punës me skedarët e medias, shihni Files API .

Kaloni të dhënat audio në linjë

Në vend që të ngarkoni një skedar audio, mund të kaloni të dhëna audio inline në kërkesën për generateContent :

Python JavaScript Shkoni 
from google.genai import types

with open('path/to/small-sample.mp3', 'rb') as f:
    audio_bytes = f.read()

response = client.models.generate_content(
  model='gemini-2.0-flash',
  contents=[
    'Describe this audio clip',
    types.Part.from_bytes(
      data=audio_bytes,
      mime_type='audio/mp3',
    )
  ]
)

print(response.text)

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

const ai = new GoogleGenAI({ apiKey: "GOOGLE_API_KEY" });
const base64AudioFile = fs.readFileSync("path/to/small-sample.mp3", {
  encoding: "base64",
});

const contents = [
  { text: "Please summarize the audio." },
  {
    inlineData: {
      mimeType: "audio/mp3",
      data: base64AudioFile,
    },
  },
];

const response = await ai.models.generateContent({
  model: "gemini-2.0-flash",
  contents: contents,
});
console.log(response.text);

// Initialize a Gemini model appropriate for your use case.
model := client.GenerativeModel("gemini-2.0-flash")

bytes, err := os.ReadFile("path/to/small-sample.mp3")
if err != nil {
  log.Fatal(err)
}

prompt := []genai.Part{
  genai.Blob{MIMEType: "audio/mp3", Data: bytes},
  genai.Text("Please summarize the audio."),
}

// Generate content using the prompt.
resp, err := model.GenerateContent(ctx, prompt...)
if err != nil {
  log.Fatal(err)
}

// Handle the response of generated text
for _, c := range resp.Candidates {
  if c.Content != nil {
    fmt.Println(*c.Content)
  }
}

Disa gjëra që duhen mbajtur parasysh në lidhje me të dhënat audio inline:

  • Madhësia maksimale e kërkesës është 20 MB, e cila përfshin kërkesat e tekstit, udhëzimet e sistemit dhe skedarët e ofruar në linjë. Nëse madhësia e skedarit tuaj do të bëjë që madhësia totale e kërkesës të kalojë 20 MB, atëherë përdorni API-në e skedarëve për të ngarkuar një skedar audio për t'u përdorur në kërkesë.
  • Nëse jeni duke përdorur një mostër audio disa herë, është më efikase të ngarkoni një skedar audio .

Merrni një transkript

Për të marrë një transkript të të dhënave audio, thjesht kërkoni atë në kërkesë:

Python JavaScript Shkoni 
myfile = client.files.upload(file='path/to/sample.mp3')
prompt = 'Generate a transcript of the speech.'

response = client.models.generate_content(
  model='gemini-2.0-flash',
  contents=[prompt, myfile]
)

print(response.text)

import {
  GoogleGenAI,
  createUserContent,
  createPartFromUri,
} from "@google/genai";

const ai = new GoogleGenAI({ apiKey: "GOOGLE_API_KEY" });
const myfile = await ai.files.upload({
  file: "path/to/sample.mp3",
  config: { mimeType: "audio/mpeg" },
});

const result = await ai.models.generateContent({
  model: "gemini-2.0-flash",
  contents: createUserContent([
    createPartFromUri(myfile.uri, myfile.mimeType),
    "Generate a transcript of the speech.",
  ]),
});
console.log("result.text=", result.text);

// Initialize a Gemini model appropriate for your use case.
model := client.GenerativeModel("gemini-2.0-flash")

// Create a prompt using text and the URI reference for the uploaded file.
prompt := []genai.Part{
  genai.FileData{URI: sampleAudio.URI},
  genai.Text("Generate a transcript of the speech."),
}

// Generate content using the prompt.
resp, err := model.GenerateContent(ctx, prompt...)
if err != nil {
  log.Fatal(err)
}

// Handle the response of generated text
for _, c := range resp.Candidates {
  if c.Content != nil {
    fmt.Println(*c.Content)
  }
}

Referojuni vulave kohore

Ju mund t'i referoheni seksioneve specifike të një skedari audio duke përdorur vulat kohore të formës MM:SS . Për shembull, kërkesa e mëposhtme kërkon një transkript që

  • Fillon në 2 minuta 30 sekonda nga fillimi i skedarit.

  • Përfundon në 3 minuta 29 sekonda nga fillimi i skedarit.

Python JavaScript Shkoni 
# Create a prompt containing timestamps.
prompt = "Provide a transcript of the speech from 02:30 to 03:29."

// Create a prompt containing timestamps.
const prompt = "Provide a transcript of the speech from 02:30 to 03:29."

// Create a prompt containing timestamps.
prompt := []genai.Part{
    genai.FileData{URI: sampleAudio.URI},
    genai.Text("Provide a transcript of the speech from 02:30 to 03:29."),
}

Numëroni argumentet

Thirrni metodën countTokens për të marrë një numërim të numrit të argumenteve në një skedar audio. Për shembull:

Python JavaScript Shkoni 
response = client.models.count_tokens(
  model='gemini-2.0-flash',
  contents=[myfile]
)

print(response)

import {
  GoogleGenAI,
  createUserContent,
  createPartFromUri,
} from "@google/genai";

const ai = new GoogleGenAI({ apiKey: "GOOGLE_API_KEY" });
const myfile = await ai.files.upload({
  file: "path/to/sample.mp3",
  config: { mimeType: "audio/mpeg" },
});

const countTokensResponse = await ai.models.countTokens({
  model: "gemini-2.0-flash",
  contents: createUserContent([
    createPartFromUri(myfile.uri, myfile.mimeType),
  ]),
});
console.log(countTokensResponse.totalTokens);

tokens, err := model.CountTokens(ctx, genai.FileData{URI: sampleAudio.URI})
if err != nil {
    log.Fatal(err)
}
fmt.Printf("File %s is %d tokens", sampleAudio.DisplayName, tokens.TotalTokens)

Formatet e mbështetura audio

Gemini mbështet llojet e mëposhtme të formatit audio MIME:

  • WAV - audio/wav
  • MP3 - audio/mp3
  • AIFF - audio/aiff
  • AAC - audio/aac
  • OGG Vorbis - audio/ogg
  • FLAC - audio/flac

Detaje teknike rreth audios

  • Binjakët përfaqësojnë çdo sekondë të audios si 32 shenja; për shembull, një minutë audio përfaqësohet si 1920 argumente.
  • Binjakët mund të nxjerrin vetëm përgjigjet ndaj të folurit në gjuhën angleze.
  • Binjakët mund të "kuptojnë" përbërës që nuk flasin, si kënga e shpendëve apo sirenat.
  • Gjatësia maksimale e mbështetur e të dhënave audio në një kërkesë të vetme është 9,5 orë. Binjakët nuk e kufizon numrin e skedarëve audio në një kërkesë të vetme; megjithatë, gjatësia totale e kombinuar e të gjithë skedarëve audio në një kërkesë të vetme nuk mund të kalojë 9,5 orë.
  • Gemini zvogëlon skedarët audio në një rezolucion të dhënash 16 Kbps.
  • Nëse burimi audio përmban shumë kanale, Gemini i kombinon ato kanale në një kanal të vetëm.

Çfarë është më pas

Ky udhëzues tregon se si të gjeneroni tekst në përgjigje të të dhënave audio. Për të mësuar më shumë, shikoni burimet e mëposhtme:

  • Strategjitë e nxitjes së skedarëve : Gemini API mbështet nxitjen me të dhëna teksti, imazhi, audio dhe video, të njohura gjithashtu si nxitje multimodale.
  • Udhëzimet e sistemit : Udhëzimet e sistemit ju lejojnë të drejtoni sjelljen e modelit bazuar në nevojat tuaja specifike dhe rastet e përdorimit.
  • Udhëzime për sigurinë : Ndonjëherë modelet gjeneruese të AI prodhojnë rezultate të papritura, të tilla si rezultate që janë të pasakta, të njëanshme ose fyese. Pas-përpunimi dhe vlerësimi njerëzor janë thelbësore për të kufizuar rrezikun e dëmtimit nga rezultate të tilla.