Rozumienie mowy

Wyświetl na ai.google.dev Uruchom w Google Colab Uruchom w Kaggle Otwórz w Vertex AI Wyświetl źródło na GitHubie

Począwszy od modelu Gemma 3n, możesz używać dźwięku bezpośrednio w promptach i przepływach pracy. Dźwięk i język mówiony są bogatymi źródłami danych, które pozwalają rejestrować intencje użytkowników, zapisywać informacje o otaczającym nas świecie i rozumieć konkretne problemy, które należy rozwiązać.

Ten przewodnik zawiera omówienie możliwości przetwarzania dźwięku przez Gemma 4, w tym automatycznego rozpoznawania mowy (ASR), tłumaczenia i ogólnego rozumienia mowy.

Ten notatnik będzie uruchamiany na procesorze graficznym T4.

Instalowanie pakietów Pythona

Zainstaluj biblioteki Hugging Face wymagane do uruchomienia modelu Gemma i wysyłania żądań.

# Install PyTorch & other libraries
pip install torch accelerate

# Install the transformers library
pip install "transformers>=5.10.1"

Wczytaj model

Użyj bibliotek transformers, aby utworzyć instancję processormodel za pomocą klas AutoProcessorAutoModelForImageTextToText, jak pokazano w tym przykładowym kodzie:

MODEL_ID = "google/gemma-4-E2B-it" # @param ["google/gemma-4-E2B-it","google/gemma-4-E4B-it", "google/gemma-4-12B-it"]

from transformers import pipeline

pipe = pipeline(
    task="any-to-any",
    model=MODEL_ID,
    device_map="auto",
    dtype="auto"
)
config.json:   0%|          | 0.00/4.95k [00:00<?, ?B/s]
model.safetensors:   0%|          | 0.00/10.2G [00:00<?, ?B/s]
Loading weights:   0%|          | 0/1951 [00:00<?, ?it/s]
generation_config.json:   0%|          | 0.00/208 [00:00<?, ?B/s]
processor_config.json:   0%|          | 0.00/1.69k [00:00<?, ?B/s]
chat_template.jinja:   0%|          | 0.00/17.3k [00:00<?, ?B/s]
tokenizer_config.json:   0%|          | 0.00/2.10k [00:00<?, ?B/s]
tokenizer.json:   0%|          | 0.00/32.2M [00:00<?, ?B/s]

Dane audio

Dane audio w formie cyfrowej mogą mieć wiele formatów i poziomów rozdzielczości. Rzeczywiste formaty audio, których możesz używać z Gemma, takie jak MP3 i WAV, są określane przez platformę, którą wybierzesz do przekształcania danych dźwiękowych w tensory. Oto kilka konkretnych kwestii, które należy wziąć pod uwagę podczas przygotowywania danych audio do przetwarzania za pomocą modelu Gemma:

  • Koszt tokenów: każda sekunda dźwięku to 25 tokenów w przypadku modelu Gemma 4. (6,25 tokena w przypadku modelu Gemma 3n).
  • Długość klipu: dźwięk może trwać maksymalnie 30 sekund.
  • Kanały audio: dane audio są przetwarzane jako pojedynczy kanał audio. Jeśli używasz dźwięku wielokanałowego, np. kanałów lewego i prawego, rozważ zmniejszenie ilości danych do jednego kanału, usuwając kanały lub łącząc dane dźwiękowe w jeden kanał.
  • Kodowanie techniczne:
    • Częstotliwość próbkowania: 16 kHz
    • Głębia bitowa: format zmiennoprzecinkowy 32-bitowy z próbkami znormalizowanymi w zakresie [-1, 1].

Jeśli dane audio, które chcesz przetworzyć, znacznie różnią się od danych wejściowych, zwłaszcza pod względem liczby kanałów, częstotliwości próbkowania i głębi bitowej, rozważ ponowne próbkowanie lub przycięcie danych audio, aby dopasować je do rozdzielczości danych obsługiwanej przez model.

Kodowanie dźwięku

Biblioteki wysokiego poziomu (np. Hugging Face AutoProcessor) często automatycznie przeprowadzają wstępne przetwarzanie dźwięku, ale czasami może być konieczne wdrożenie niestandardowego kodowania.

Podczas kodowania danych audio za pomocą własnej implementacji kodu do użytku z Gemma należy postępować zgodnie z zalecanym procesem konwersji. Jeśli pracujesz z plikami audio zakodowanymi w określonym formacie, np. MP3 lub WAV, musisz najpierw zdekodować je do próbek za pomocą biblioteki takiej jak ffmpeg. Po zdekodowaniu danych przekonwertuj dźwięk na jednokanałowe przebiegi float32 o częstotliwości 16 kHz w zakresie [-1, 1]. Jeśli na przykład pracujesz ze stereofonicznymi plikami WAV z 16-bitowymi liczbami całkowitymi PCM ze znakiem o częstotliwości próbkowania 44, 1 kHz, wykonaj te czynności:

  • Ponownie spróbkuj dane audio do 16 kHz.
  • Downmix z stereo do mono przez uśrednienie 2 kanałów
  • Przekonwertuj wartość z typu int16 na float32 i podziel przez 32768.0, aby przeskalować ją do zakresu [-1, 1].

Zamiana mowy na tekst

Modele Gemma 4 E2B, E4B i 12B Unified są trenowane pod kątem wielojęzycznego rozpoznawania mowy, co umożliwia transkrypcję danych wejściowych audio w różnych językach na tekst.

W przypadku automatycznego rozpoznawania mowy (ASR) użyj tej struktury prompta:

Transcribe the following speech segment in {LANGUAGE} into {LANGUAGE} text.

Follow these specific instructions for formatting the answer:
*   Only output the transcription, with no newlines.
*   When transcribing numbers, write the digits, i.e. write 1.7 and not one point seven, and write 3 instead of three.

Poniższe przykłady kodu pokazują, jak poprosić model o transkrypcję tekstu z plików audio za pomocą Hugging Face Transformers:

from transformers import GenerationConfig
config = GenerationConfig.from_pretrained(MODEL_ID)
config.max_new_tokens = 64
gen_kwargs = dict(generation_config=config)

RESOURCE_URL_PREFIX = "https://raw.githubusercontent.com/google-gemma/cookbook/refs/heads/main/apps/sample-data/"

messages = [
    {
        "role": "user",
        "content": [
            {"type": "text", "text": "Transcribe the following speech segment in its original language. Follow these specific instructions for formatting the answer:\n* Only output the transcription, with no newlines.\n* When transcribing numbers, write the digits, i.e. write 1.7 and not one point seven, and write 3 instead of three."},
            #{"type": "text", "text": "Transcribe the following speech segment in English into English text. Follow these specific instructions for formatting the answer:\n* Only output the transcription, with no newlines.\n* When transcribing numbers, write the digits, i.e. write 1.7 and not one point seven, and write 3 instead of three."},
            {"type": "audio", "audio": f"{RESOURCE_URL_PREFIX}journal1.wav"},
        ]
    }
]

outputs = pipe(messages, return_full_text=False, generate_kwargs=gen_kwargs)
print(outputs[0]['generated_text'])
I woke up early today feeling really fresh the morning light was beautiful and I enjoyed a nice cup of coffee<turn|>
from transformers import GenerationConfig
config = GenerationConfig.from_pretrained(MODEL_ID)
config.max_new_tokens = 1024
gen_kwargs = dict(generation_config=config)

messages = [
    {
        "role": "user",
        "content": [
            {"type": "text", "text": "Give me a concise overview of these audio files."},
            {"type": "text", "text": "journal1:"},
            {"type": "audio", "audio": f"{RESOURCE_URL_PREFIX}journal1.wav"},
            {"type": "text", "text": "journal2:"},
            {"type": "audio", "audio": f"{RESOURCE_URL_PREFIX}journal2.wav"},
            {"type": "text", "text": "journal3:"},
            {"type": "audio", "audio": f"{RESOURCE_URL_PREFIX}journal3.wav"},
            {"type": "text", "text": "journal4:"},
            {"type": "audio", "audio": f"{RESOURCE_URL_PREFIX}journal4.wav"},
            {"type": "text", "text": "journal5:"},
            {"type": "audio", "audio": f"{RESOURCE_URL_PREFIX}journal5.wav"},
        ]
    }
]

outputs = pipe(messages, return_full_text=False, generate_kwargs=gen_kwargs)
print(outputs[0]['generated_text'])
Here is a concise overview of each audio file:

**journal1:** The speaker describes a fresh and peaceful day, enjoying a cup of coffee.
**journal2:** The speaker had a perfect day at the park, including a walk and watching cherry blossoms.
**journal3:** The speaker finished the day with a good book, feeling grateful for simple moments.
**journal4:** The speaker returned from work and noted the beautiful night sky and a clear view from the train.
**journal5:** The speaker had a great lunch with an old friend, which was a pleasant way to catch up and made their day.
<turn|>

Automatyczne tłumaczenie mowy

Modele Gemma 4 E2B, E4B i 12B Unified są trenowane pod kątem wielojęzycznego tłumaczenia mowy, co umożliwia tłumaczenie tekstu mówionego bezpośrednio na inny język.

W przypadku automatycznego tłumaczenia mowy (AST) użyj tej struktury promptu:

Transcribe the following speech segment in {SOURCE_LANGUAGE}, then translate it into {TARGET_LANGUAGE}.
When formatting the answer, first output the transcription in {SOURCE_LANGUAGE}, then one newline, then output the string '{TARGET_LANGUAGE}: ', then the translation in {TARGET_LANGUAGE}.

Poniższe przykłady kodu pokazują, jak poprosić model o przetłumaczenie tekstu mówionego na tekst za pomocą Hugging Face Transformers:

from transformers import GenerationConfig
config = GenerationConfig.from_pretrained(MODEL_ID)
config.max_new_tokens = 64
gen_kwargs = dict(generation_config=config)

messages = [
    {
        "role": "user",
        "content": [
            {"type": "text", "text": "Transcribe the following speech segment in English, then translate it into Korean. When formatting the answer, first output the transcription in English, then one newline, then output the string 'Korean: ', then the translation in Korean."},
            {"type": "audio", "audio": "https://ai.google.dev/gemma/docs/audio/roses-are.wav"},
        ]
    }
]

outputs = pipe(messages, return_full_text=False, generate_kwargs=gen_kwargs)
print(outputs[0]['generated_text'])
Roses are red, violets are blue.
Korean: 장미는 빨갛고, 제비꽃은 파랗다.<turn|>

Automatyczne tłumaczenie mowy / automatyczne rozpoznawanie mowy

Wypróbuj to

pip install ipywebrtc

Naciśnij okrągły przycisk i zacznij mówić. Gdy skończysz, ponownie kliknij przycisk w kółku. Widżet natychmiast zacznie odtwarzać zarejestrowany dźwięk.

from google.colab import output
output.enable_custom_widget_manager()

from ipywebrtc import AudioRecorder, CameraStream

camera = CameraStream(constraints={'audio': True,'video':False})
recorder = AudioRecorder(stream=camera)
recorder
AudioRecorder(audio=Audio(value=b'', format='webm'), stream=CameraStream(constraints={'audio': True, 'video': …

Przekonwertuj plik webm na format wav, który może odczytać PyTorch.

with open('/content/recording.webm', 'wb') as f:
    f.write(recorder.audio.value)
!ffmpeg -i /content/recording.webm /content/recording.wav -y
ffmpeg version 4.4.2-0ubuntu0.22.04.1 Copyright (c) 2000-2021 the FFmpeg developers
  built with gcc 11 (Ubuntu 11.2.0-19ubuntu1)
  configuration: --prefix=/usr --extra-version=0ubuntu0.22.04.1 --toolchain=hardened --libdir=/usr/lib/x86_64-linux-gnu --incdir=/usr/include/x86_64-linux-gnu --arch=amd64 --enable-gpl --disable-stripping --enable-gnutls --enable-ladspa --enable-libaom --enable-libass --enable-libbluray --enable-libbs2b --enable-libcaca --enable-libcdio --enable-libcodec2 --enable-libdav1d --enable-libflite --enable-libfontconfig --enable-libfreetype --enable-libfribidi --enable-libgme --enable-libgsm --enable-libjack --enable-libmp3lame --enable-libmysofa --enable-libopenjpeg --enable-libopenmpt --enable-libopus --enable-libpulse --enable-librabbitmq --enable-librubberband --enable-libshine --enable-libsnappy --enable-libsoxr --enable-libspeex --enable-libsrt --enable-libssh --enable-libtheora --enable-libtwolame --enable-libvidstab --enable-libvorbis --enable-libvpx --enable-libwebp --enable-libx265 --enable-libxml2 --enable-libxvid --enable-libzimg --enable-libzmq --enable-libzvbi --enable-lv2 --enable-omx --enable-openal --enable-opencl --enable-opengl --enable-sdl2 --enable-pocketsphinx --enable-librsvg --enable-libmfx --enable-libdc1394 --enable-libdrm --enable-libiec61883 --enable-chromaprint --enable-frei0r --enable-libx264 --enable-shared
  libavutil      56. 70.100 / 56. 70.100
  libavcodec     58.134.100 / 58.134.100
  libavformat    58. 76.100 / 58. 76.100
  libavdevice    58. 13.100 / 58. 13.100
  libavfilter     7.110.100 /  7.110.100
  libswscale      5.  9.100 /  5.  9.100
  libswresample   3.  9.100 /  3.  9.100
  libpostproc    55.  9.100 / 55.  9.100
Input #0, matroska,webm, from '/content/recording.webm':
  Metadata:
    encoder         : Chrome
  Duration: 00:00:03.00, start: 0.000000, bitrate: 132 kb/s
  Stream #0:0(eng): Audio: opus, 48000 Hz, mono, fltp (default)
Stream mapping:
  Stream #0:0 -> #0:0 (opus (native) -> pcm_s16le (native))
Press [q] to stop, [?] for help
Output #0, wav, to '/content/recording.wav':
  Metadata:
    ISFT            : Lavf58.76.100
  Stream #0:0(eng): Audio: pcm_s16le ([1][0][0][0] / 0x0001), 48000 Hz, mono, s16, 768 kb/s (default)
    Metadata:
      encoder         : Lavc58.134.100 pcm_s16le
size=     287kB time=00:00:02.99 bitrate= 783.7kbits/s speed=79.4x    
video:0kB audio:287kB subtitle:0kB other streams:0kB global headers:0kB muxing overhead: 0.026552%

ASR

from transformers import GenerationConfig
config = GenerationConfig.from_pretrained(MODEL_ID)
config.max_new_tokens = 64
gen_kwargs = dict(generation_config=config)

messages = [{
  "role": "user",
  "content": [
    {"type": "text", "text": "Transcribe the following speech segment in its original language. Follow these specific instructions for formatting the answer:\n* Only output the transcription, with no newlines.\n* When transcribing numbers, write the digits, i.e. write 1.7 and not one point seven, and write 3 instead of three."},
    {"type": "audio", "audio": "/content/recording.wav"},
  ]
}]

outputs = pipe(messages, return_full_text=False, generate_kwargs=gen_kwargs)
print(outputs[0]['generated_text'])
How can I get to the station?<turn|>

AST

messages = [{
  "role": "user",
  "content": [
    {"type": "text", "text": "Transcribe the following speech segment in English, then translate it into Korean. When formatting the answer, first output the transcription in English, then one newline, then output the string 'Korean: ', then the translation in Korean."},
    {"type": "audio", "audio": "/content/recording.wav"},
  ]
}]

outputs = pipe(messages, return_full_text=False, generate_kwargs=gen_kwargs)
print(outputs[0]['generated_text'])
How can I get to the station?
Korean: 역에 어떻게 가나요?<turn|>

Podsumowanie i dalsze kroki

Z tego przewodnika dowiesz się, jak przetwarzać dźwięk za pomocą modeli Gemma 4. Przykłady pokazywały, jak używać funkcji zamiany mowy na tekst (ASR) do transkrypcji języka mówionego, a także automatycznego tłumaczenia mowy (AST) do tłumaczenia tekstu mówionego bezpośrednio na inny język. Pokazaliśmy też, jak przechwytywać dźwięk z mikrofonu w środowisku notatnika do przetwarzania.

Więcej informacji znajdziesz w tych dokumentach: