Geração de música usando o Lyria RealTime

A API Gemini, usando o Lyria RealTime, oferece acesso a um modelo de geração de música por streaming em tempo real de última geração. Ele permite que os desenvolvedores criem aplicativos em que os usuários podem criar, direcionar e tocar músicas instrumentais de forma interativa.

Para saber o que pode ser criado com o Lyria RealTime, teste no AI Studio usando os apps Prompt DJ ou MIDI DJ.

Como a geração de música funciona

A geração de música em tempo real do Lyria usa uma conexão de streaming persistente, bidirecional e de baixa latência usando WebSocket.

Gerar e controlar músicas

O Lyria RealTime funciona um pouco como a API Live, já que usa websockets para manter uma comunicação em tempo real com o modelo. Ainda não é exatamente a mesma coisa, porque não é possível conversar com o modelo e é preciso usar um formato específico para fazer solicitações.

O código a seguir demonstra como gerar música:

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

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

  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: "v1alpha" ,
});

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);

Em seguida, use session.play(), session.pause(), session.stop() e session.reset_context() para iniciar, pausar, interromper ou redefinir a sessão.

Conduzir a música em tempo real

Comando do Lyria RealTime

Enquanto a transmissão estiver ativa, você pode enviar novas mensagens de WeightedPrompt a qualquer momento para alterar a música gerada. O modelo fará uma transição suave com base na nova entrada.

Os comandos precisam seguir o formato correto com um text (o comando real) e um weight. O weight pode assumir qualquer valor, exceto 0. 1.0 costuma ser um bom ponto de partida.

  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.setMusicGenerationConfig({
    weightedPrompts: [
      { text: 'Harmonica', weight: 0.3 },
      { text: 'Afrobeat', weight: 0.7 }
    ],
  });

As transições de modelo podem ser um pouco abruptas ao mudar drasticamente os comandos. Por isso, recomendamos implementar algum tipo de fade-out cruzado enviando valores de ponderação intermediários ao modelo.

Atualizar a configuração

Também é possível atualizar os parâmetros de geração de música em tempo real. Não é possível apenas atualizar um parâmetro. É necessário definir toda a configuração. Caso contrário, os outros campos serão redefinidos para os valores padrão.

Como a atualização do bpm ou da escala é uma mudança drástica para o modelo, você também precisa pedir que ele redefina o contexto usando reset_context() para considerar a nova configuração. Isso não vai interromper a transmissão, mas será uma transição difícil. Não é necessário fazer isso para os outros parâmetros.

  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();

Guia de comandos para o Lyria RealTime

Confira uma lista não exaustiva de comandos que você pode usar para acionar o Lyria RealTime:

• Instrumentos: 303 Acid Bass, 808 Hip Hop Beat, Accordion, Alto Saxophone, Bagpipes, Balalaika Ensemble, Banjo, Bass Clarinet, Bongos, Boomy Bass, Bouzouki, Buchla Synths, Cello, Charango, Clavichord, Conga Drums, Didgeridoo, Dirty Synths, Djembe, Drumline, Dulcimer, Fiddle, Flamenco Guitar, Funk Drums, Glockenspiel, Guitar, Hang Drum, Harmonica, Harp, Harpsichord, Hurdy-gurdy, Kalimba, Koto, Lyre, Mandolin, Maracas, Marimba, Mbira, Mellotron, Metallic Twang, Moog Oscillations, Ocarina, Persian Tar, Pipa, Precision Bass, Ragtime Piano, Rhodes Piano, Shamisen, Shredding Guitar, Sitar, Slide Guitar, Smooth Pianos, Spacey Synths, Steel Drum, Synth Pads, Tabla, TR-909 Drum Machine, Trumpet, Tuba, Vibraphone, Viola Ensemble, Warm Acoustic Guitar, Woodwinds, ...
• Gênero musical: Acid Jazz, Afrobeat, Alternative Country, Baroque, Bengal Baul, Bhangra, Bluegrass, Blues Rock, Bossa Nova, Breakbeat, Celtic Folk, Chillout, Chiptune, Classic Rock, Contemporary R&B, Cumbia, Deep House, Disco Funk, Drum & Bass, Dubstep, EDM, Electro Swing, Funk Metal, G-funk, Garage Rock, Glitch Hop, Grime, Hyperpop, Indian Classical, Indie Electronic, Indie Folk, Indie Pop, Irish Folk, Jam Band, Jamaican Dub, Jazz Fusion, Latin Jazz, Lo-Fi Hip Hop, Marching Band, Merengue, New Jack Swing, Minimal Techno, Moombahton, Neo-Soul, Orchestral Score, Piano Ballad, Polka, Post-Punk, 60s Psychedelic Rock, Psytrance, R&B, Reggae, Reggaeton, Renaissance Music, Salsa, Shoegaze, Ska, Surf Rock, Synthpop, Techno, Trance, Trap Beat, Trip Hop, Vaporwave, Witch house, ...
• Humor/descrição: Acoustic Instruments, Ambient, Bright Tones, Chill, Crunchy Distortion, Danceable, Dreamy, Echo, Emotional, Ethereal Ambience, Experimental, Fat Beats, Funky, Glitchy Effects, Huge Drop, Live Performance, Lo-fi, Ominous Drone, Psychedelic, Rich Orchestration, Saturated Tones, Subdued Melody, Sustained Chords, Swirling Phasers, Tight Groove, Unsettling, Upbeat, Virtuoso, Weird Noises, ...

Esses são apenas alguns exemplos. O Lyria RealTime pode fazer muito mais. Teste seus próprios comandos!

Práticas recomendadas

• Os aplicativos cliente precisam implementar um buffer de áudio robusto para garantir uma reprodução suave. Isso ajuda a explicar o jitter da rede e pequenas variações na latência de geração.
• Comandos eficazes:
  • Utilize descrições. Use adjetivos que descrevam o clima, o gênero e a instrumentação.
  • Faça iterações e direcione gradualmente. Em vez de mudar completamente o comando, adicione ou modifique elementos para transformar a música de maneira mais suave.
  • Teste o peso em WeightedPrompt para influenciar a intensidade com que um novo comando afeta a geração em andamento.

Detalhes técnicos

Esta seção descreve os detalhes de como usar a geração de música em tempo real do Lyria.

Especificações

• Formato de saída: áudio PCM bruto de 16 bits
• Taxa de amostragem: 48 kHz
• Canais: 2 (estéreo)

Controles

A geração de música pode ser influenciada em tempo real enviando mensagens com:

• WeightedPrompt: uma string de texto que descreve uma ideia musical, um gênero, um instrumento, um clima ou uma característica. Vários comandos podem ser fornecidos para combinar influências. Consulte acima para mais detalhes sobre como dar comandos à Lyria RealTime.
• MusicGenerationConfig: configuração do processo de geração de música, que influencia as características do áudio de saída. Os parâmetros incluem:
  • guidance: (ponto flutuante) Intervalo: [0.0, 6.0]. Padrão: 4.0. Controla o nível de rigor com que o modelo segue os comandos. Uma orientação mais alta melhora a aderência ao comando, mas torna as transições mais abruptas.
  • bpm: (int) Intervalo: [60, 200]. Define os batimentos por minuto que você quer para a música gerada. Você precisa parar/tocar ou redefinir o contexto para que o modelo considere o novo bpm.
  • density: (ponto flutuante) Intervalo: [0.0, 1.0]. Controla a densidade das notas/sons musicais. Valores mais baixos produzem músicas mais esparsas, e valores mais altos produzem músicas mais "agitadas".
  • brightness: (ponto flutuante) Intervalo: [0.0, 1.0]. Ajusta a qualidade tonal. Valores mais altos produzem um áudio mais "brilhante", geralmente enfatizando frequências mais altas.
  • scale: (enum) Define a escala musical (chave e modo) para a geração. Use os valores de enumeração Scale fornecidos pelo SDK. Você precisa parar/tocar ou redefinir o contexto para que o modelo considere a nova escala.
  • mute_bass: (bool) Padrão: False. Controla se o modelo reduz o baixo das saídas.
  • mute_drums: (bool) Padrão: False. Controla se a saída do modelo reduz a bateria das saídas.
  • only_bass_and_drums: (bool) Padrão: False. Direcione o modelo para tentar gerar apenas baixo e bateria.
  • music_generation_mode: (enumeração) Indica ao modelo se ele deve se concentrar na QUALITY (valor padrão) ou na DIVERSITY da música. Também é possível definir como VOCALIZATION para que o modelo gere vocalizações como outro instrumento (adicione-as como novos comandos).
• PlaybackControl: comandos para controlar aspectos da reprodução, como tocar, pausar, parar ou redefinir o contexto.

Para bpm, density, brightness e scale, se nenhum valor for fornecido, o modelo vai decidir o que é melhor de acordo com seus comandos iniciais.

Outros parâmetros mais clássicos, como temperature (0,0 a 3,0, padrão 1,1), top_k (1 a 1.000, padrão 40) e seed (0 a 2.147.483.647, selecionado aleatoriamente por padrão), também podem ser personalizados no MusicGenerationConfig.

Dimensionar valores de tipo enumerado

Estes são todos os valores de escala que o modelo pode aceitar:

O modelo consegue orientar as notas tocadas, mas não distingue entre teclas relativas. Assim, cada enumeração corresponde ao principal e ao secundário relativos. Por exemplo, C_MAJOR_A_MINOR corresponderia a todas as teclas brancas de um piano, e F_MAJOR_D_MINOR seria todas as teclas brancas, exceto si bemol.

Limitações

• Somente instrumental: o modelo gera apenas músicas instrumentais.
• Segurança: os comandos são verificados por filtros de segurança. Os comandos que acionam os filtros serão ignorados. Nesse caso, uma explicação será escrita no campo filtered_prompt da saída.
• Marca d'água: o áudio de saída sempre recebe uma marca d'água para identificação, seguindo nossos princípios de IA responsável.

A seguir

• Em vez de música, aprenda a gerar conversas com vários falantes usando os modelos de TTS.
• Descubra como gerar imagens ou vídeos,
• Em vez de gerar músicas ou áudio, saiba como o Gemini pode entender arquivos de áudio,
• Converse em tempo real com o Gemini usando a API Live.

Confira o Cookbook para mais exemplos de código e tutoriais.