Generowanie muzyki w czasie rzeczywistym za pomocą Lyrii RealTime

Gemini API korzystający z Lyrii RealTime zapewnia dostęp do najnowocześniejszego modelu generowania muzyki w czasie rzeczywistym. Umożliwia deweloperom tworzenie aplikacji, w których użytkownicy mogą interaktywnie tworzyć, nieustannie sterować i wykonywać muzykę instrumentalną.

Generowanie muzyki w Lyria RealTime wykorzystuje trwałe, dwukierunkowe połączenie strumieniowe o niskim opóźnieniu za pomocą protokołu WebSocket.

Aby sprawdzić, co można stworzyć za pomocą Lyrii RealTime, wypróbuj ją w AI Studio, korzystając z aplikacji Prompt DJ lub MIDI DJ.

Generowanie muzyki i zarządzanie nią

Lyria RealTime działa podobnie do Live API, ponieważ używa protokołu Websockets do utrzymywania komunikacji z modelem w czasie rzeczywistym.

Poniższy kod pokazuje, jak wygenerować muzykę:

  import asyncio
  from google import genai
  from google.genai import types

  client = genai.Client(http_options={'api_version': 'v1beta'})

  async def main():
      async def receive_audio(session):
        """Example background task to process incoming audio."""
        while True:
          async for message in session.receive():
            audio_data = message.server_content.audio_chunks[0].data
            # Process audio...
            await asyncio.sleep(10**-12)

      async with (
        client.aio.live.music.connect(model='models/lyria-realtime-exp') as session,
        asyncio.TaskGroup() as tg,
      ):
        # Set up task to receive server messages.
        tg.create_task(receive_audio(session))

        # Send initial prompts and config
        await session.set_weighted_prompts(
          prompts=[
            types.WeightedPrompt(text='minimal techno', weight=1.0),
          ]
        )
        await session.set_music_generation_config(
          config=types.LiveMusicGenerationConfig(bpm=90, temperature=1.0)
        )

        # Start streaming music
        await session.play()
  if __name__ == "__main__":
      asyncio.run(main())

import { GoogleGenAI } from "@google/genai";
import Speaker from "speaker";
import { Buffer } from "buffer";

const client = new GoogleGenAI({
  apiKey: GEMINI_API_KEY,
    apiVersion: "v1beta" ,
});

async function main() {
  const speaker = new Speaker({
    channels: 2,       // stereo
    bitDepth: 16,      // 16-bit PCM
    sampleRate: 44100, // 44.1 kHz
  });

  const session = await client.live.music.connect({
    model: "models/lyria-realtime-exp",
    callbacks: {
      onmessage: (message) => {
        if (message.serverContent?.audioChunks) {
          for (const chunk of message.serverContent.audioChunks) {
            const audioBuffer = Buffer.from(chunk.data, "base64");
            speaker.write(audioBuffer);
          }
        }
      },
      onerror: (error) => console.error("music session error:", error),
      onclose: () => console.log("Lyria RealTime stream closed."),
    },
  });

  await session.setWeightedPrompts({
    weightedPrompts: [
      { text: "Minimal techno with deep bass, sparse percussion, and atmospheric synths", weight: 1.0 },
    ],
  });

  await session.setMusicGenerationConfig({
    musicGenerationConfig: {
      bpm: 90,
      temperature: 1.0,
      audioFormat: "pcm16",  // important so we know format
      sampleRateHz: 44100,
    },
  });

  await session.play();
}

main().catch(console.error);

Następnie możesz użyć przycisków session.play(), session.pause(), session.stop() i session.reset_context(), aby rozpocząć, wstrzymać, zatrzymać lub zresetować sesję.

Sterowanie muzyką w czasie rzeczywistym

Możesz sterować generowaniem muzyki w czasie rzeczywistym, wysyłając prompty i aktualizując parametry generowania w czasie rzeczywistym.

Prompt Lyria RealTime

Podczas transmisji możesz w dowolnym momencie wysyłać nowe WeightedPrompt wiadomości, aby zmieniać generowaną muzykę. Model będzie płynnie przechodzić na podstawie nowych danych wejściowych.

Prompty muszą mieć odpowiedni format: text (rzeczywisty prompt) i weight. Symbol weight może przyjmować dowolną wartość z wyjątkiem 0. 1.0to zwykle dobry punkt początkowy.

  from google.genai import types

  await session.set_weighted_prompts(
    prompts=[
      {"text": "Piano", "weight": 2.0},
      types.WeightedPrompt(text="Meditation", weight=0.5),
      types.WeightedPrompt(text="Live Performance", weight=1.0),
    ]
  )

  await session.setWeightedPrompts({
    weightedPrompts: [
      { text: 'Harmonica', weight: 0.3 },
      { text: 'Afrobeat', weight: 0.7 }
    ],
  });

Pamiętaj, że przejścia między modelami mogą być nieco nagłe, gdy drastycznie zmieniasz prompty, dlatego zalecamy wprowadzenie pewnego rodzaju przenikania poprzez wysyłanie do modelu pośrednich wartości wagi.

Aktualizowanie konfiguracji

Możesz sterować generowaniem muzyki, aktualizując parametry generowania muzyki w czasie rzeczywistym. Nie możesz po prostu zaktualizować parametru. Musisz ustawić całą konfigurację, w przeciwnym razie inne pola zostaną przywrócone do wartości domyślnych.

Zmiana tempa lub skali to drastyczna zmiana dla modelu, więc musisz też poinformować go, aby zresetował swój kontekst za pomocą reset_context(), aby uwzględnić nową konfigurację. Nie spowoduje to zatrzymania transmisji, ale będzie to nagłe przejście. Nie musisz tego robić w przypadku pozostałych parametrów.

  from google.genai import types

  await session.set_music_generation_config(
    config=types.LiveMusicGenerationConfig(
      bpm=128,
      scale=types.Scale.D_MAJOR_B_MINOR,
      music_generation_mode=types.MusicGenerationMode.QUALITY
    )
  )
  await session.reset_context();

  await session.setMusicGenerationConfig({
    musicGenerationConfig: { 
      bpm: 120,
      density: 0.75,
      musicGenerationMode: MusicGenerationMode.QUALITY
    },
  });
  await session.reset_context();

Promptowanie Lyria RealTime

Lyria RealTime wykorzystuje prompty ważone, aby dynamicznie łączyć gatunki muzyczne, instrumenty i nastroje. Aby poznać strategie sterowania promptami, słowniki tagów słów kluczowych i pełne przykłady promptów, zapoznaj się z przewodnikiem po tworzeniu promptów Lyrii.

Sprawdzone metody

• Aplikacje klienckie muszą implementować zaawansowane buforowanie dźwięku, aby zapewnić płynne odtwarzanie. Pomaga to uwzględnić wahania sieci i niewielkie różnice w czasie oczekiwania na wygenerowanie odpowiedzi.
• Skuteczne prompty:
  • Stosuj styl opisowy. Używaj przymiotników opisujących nastrój, gatunek i instrumenty.
  • Stopniowo wprowadzaj zmiany i kieruj rozwojem. Zamiast całkowicie zmieniać prompta, spróbuj dodać lub zmodyfikować elementy, aby płynniej przekształcić muzykę.
  • Eksperymentuj z wagą na WeightedPrompt, aby wpływać na to, jak silnie nowy prompt wpływa na bieżące generowanie.

Szczegóły techniczne

W tej sekcji opisaliśmy szczegóły korzystania z generowania muzyki w czasie rzeczywistym za pomocą Lyria RealTime.

Specyfikacja

• Format wyjściowy: surowy 16-bitowy dźwięk PCM
• Częstotliwość próbkowania: 48 kHz
• Kanały: 2 (stereo)

Opcje

Na generowanie muzyki można wpływać w czasie rzeczywistym, wysyłając wiadomości zawierające:

• WeightedPrompt: ciąg tekstowy opisujący pomysł muzyczny, gatunek, instrument, nastrój lub cechę. Można podać wiele promptów, aby połączyć wpływy. Więcej informacji o tym, jak najlepiej tworzyć prompty dla Lyrii RealTime, znajdziesz powyżej.
• MusicGenerationConfig: konfiguracja procesu generowania muzyki, która wpływa na charakterystykę wyjściowego dźwięku. Parametry obejmują:
  • guidance: (float) Zakres: [0.0, 6.0]. Domyślnie: 4.0. Określa, jak ściśle model ma się stosować do promptów. Wyższe wartości parametru guidance zwiększają zgodność z promptem, ale sprawiają, że przejścia są bardziej nagłe.
  • bpm: (int) Zakres: [60, 200]. Ustawia liczbę uderzeń na minutę, którą chcesz uzyskać w wygenerowanej muzyce. Musisz zatrzymać/odtworzyć lub zresetować kontekst modelu, aby uwzględnić nowe BPM.
  • density: (float) Zakres: [0.0, 1.0]. Określa gęstość nut i dźwięków. Niższe wartości dają rzadszą muzykę, a wyższe – „gęstszą”.
  • brightness: (float) Zakres: [0.0, 1.0]. Dostosowuje jakość tonalną. Wyższe wartości powodują, że dźwięk jest „jaśniejszy”, a wyższe częstotliwości są bardziej podkreślone.
  • scale: (Enum) Ustawia skalę muzyczną (tonację i tryb) na potrzeby generowania. Użyj wartości wyliczeniowych Scale udostępnianych przez pakiet SDK. Musisz zatrzymać/odtworzyć lub zresetować kontekst modelu, aby uwzględnić nową skalę.
  • mute_bass: (bool) Domyślnie: False. Określa, czy model ma redukować basy w danych wyjściowych.
  • mute_drums: (bool) Domyślnie: False. Określa, czy dane wyjściowe modelu mają zmniejszać głośność perkusji.
  • only_bass_and_drums: (bool) Domyślnie: False. Skieruj model tak, aby próbował generować tylko bas i perkusję.
  • music_generation_mode: (Enum) Informuje model, czy ma się skupić na QUALITY (wartość domyślna) czy na DIVERSITY muzyki. Można też ustawić wartość VOCALIZATION, aby model generował wokalizacje jako kolejny instrument (dodawał je jako nowe prompty).
• PlaybackControl: polecenia sterujące odtwarzaniem, takie jak odtwarzanie, wstrzymywanie, zatrzymywanie lub resetowanie kontekstu.

W przypadku parametrów bpm, density, brightness i scale, jeśli nie podasz żadnej wartości, model sam zdecyduje, co będzie najlepsze w odpowiedzi na Twoje początkowe prompty.

W MusicGenerationConfig można też dostosować bardziej klasyczne parametry, takie jak temperature (od 0,0 do 3,0, domyślnie 1,1), top_k (od 1 do 1000, domyślnie 40) i seed (od 0 do 2 147 483 647, domyślnie wybierany losowo).

Skalowanie wartości typu wyliczeniowego

Oto wszystkie wartości skali, które model może zaakceptować:

Model może prowadzić odtwarzane nuty, ale nie rozróżnia tonacji względnych. Każdy typ wyliczeniowy odpowiada więc zarówno względnej wersji głównej, jak i wersji podrzędnej. Na przykład C_MAJOR_A_MINOR odpowiadałoby wszystkim białym klawiszom fortepianu, a F_MAJOR_D_MINOR – wszystkim białym klawiszom z wyjątkiem B-flat.

Ograniczenia

• Tylko muzyka instrumentalna: model generuje tylko muzykę instrumentalną.
• Bezpieczeństwo: prompty są sprawdzane przez filtry bezpieczeństwa. Prompty wywołujące filtry zostaną zignorowane, a wyjaśnienie zostanie zapisane w polu filtered_prompt w danych wyjściowych.
• Dodawanie znaków wodnych: wygenerowany dźwięk jest zawsze oznaczony znakiem wodnym, który umożliwia identyfikację zgodnie z naszymi zasadami odpowiedzialnej AI.

Co dalej?

• Generuj pełne utwory i ścieżki wokalne za pomocą Lyrii 3.5.
• Zamiast muzyki dowiedz się, jak generować rozmowy z udziałem wielu osób za pomocą modeli TTS.
• Dowiedz się, jak generować obrazy i filmy.
• Zamiast generować muzykę lub dźwięk dowiedz się, jak Gemini może rozumieć pliki audio.
• Prowadź rozmowę w czasie rzeczywistym z Gemini za pomocą interfejsu Live API.

Więcej przykładów kodu i samouczków znajdziesz w Cookbooku.