Génération de musique en temps réel avec Lyria RealTime

L'API Gemini, qui utilise Lyria RealTime, donne accès à un modèle de génération de musique en streaming, en temps réel et de pointe. Elle permet aux développeurs de créer des applications dans lesquelles les utilisateurs peuvent créer, diriger et interpréter de la musique instrumentale de manière interactive et continue.

La génération de musique Lyria RealTime utilise une connexion de streaming persistante, bidirectionnelle, à faible latence à l'aide de WebSocket.

Pour découvrir ce qu'il est possible de créer avec Lyria RealTime, essayez-le dans AI Studio à l'aide des applications Prompt DJ ou MIDI DJ.

Générer et contrôler de la musique

Lyria RealTime fonctionne de la même manière que l'API Live en ce sens qu'elle utilise des WebSockets pour maintenir une communication en temps réel avec le modèle.

Le code suivant montre comment générer de la musique :

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

Vous pouvez ensuite utiliser session.play(), session.pause(), session.stop() et session.reset_context() pour démarrer, mettre en pause, arrêter ou réinitialiser la session.

Diriger la musique en temps réel

Vous pouvez diriger la génération de musique en temps réel en envoyant des requêtes et en mettant à jour les paramètres de génération en temps réel.

Demander à Lyria RealTime

Lorsque le flux est actif, vous pouvez envoyer de nouveaux messages WeightedPrompt à tout moment pour modifier la musique générée. Le modèle effectue une transition en douceur en fonction de la nouvelle entrée.

Les requêtes doivent respecter le bon format avec un text (la requête proprement dite) et un weight. Le weight peut prendre n'importe quelle valeur, sauf 0. 1.0 est généralement un bon point de départ.

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

Notez que les transitions de modèle peuvent être un peu abruptes lorsque vous modifiez radicalement les requêtes. Il est donc recommandé d'implémenter une sorte de fondu enchaîné en envoyant des valeurs de pondération intermédiaires au modèle.

Mettre à jour la configuration

Vous pouvez diriger la génération de musique en mettant à jour les paramètres de génération de musique en temps réel. Vous ne pouvez pas simplement mettre à jour un paramètre. Vous devez définir l'ensemble de la configuration, sinon les autres champs seront réinitialisés à leurs valeurs par défaut.

Étant donné que la modification du BPM ou de la gamme constitue un changement radical pour le modèle, vous devez également lui demander de réinitialiser son contexte à l'aide de reset_context() pour prendre en compte la nouvelle configuration. Le flux ne s'arrête pas, mais la transition sera difficile. Vous n'avez pas besoin de le faire pour les autres paramètres.

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

Guide de requête pour Lyria RealTime

Voici une liste non exhaustive de requêtes que vous pouvez utiliser pour demander à Lyria RealTime :

• Instruments: 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, ...
• Genre 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, ...
• Ambiance/Description : 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, ...

Ce ne sont là que quelques exemples. Lyria RealTime peut faire bien plus. Essayez vos propres requêtes.

Bonnes pratiques

• Les applications clientes doivent implémenter une mise en mémoire tampon audio robuste pour garantir une lecture fluide. Cela permet de tenir compte de la gigue du réseau et des légères variations de la latence de génération.
• Requêtes efficaces :
  • Utilisez des mots clés descriptifs. Utilisez des adjectifs décrivant l'ambiance, le genre et l'instrumentation.
  • Itérez et dirigez progressivement. Plutôt que de modifier complètement la requête, essayez d'ajouter ou de modifier des éléments pour transformer la musique plus en douceur.
  • Testez la pondération sur WeightedPrompt pour influencer la force avec laquelle une nouvelle requête affecte la génération en cours.

Détails techniques

Cette section décrit les spécificités de l'utilisation de la génération de musique Lyria RealTime.

Spécifications

• Format de sortie : audio PCM 16 bits brut
• Taux d'échantillonnage : 48 kHz
• Chaînes : 2 (stéréo)

Commandes

La génération de musique peut être influencée en temps réel en envoyant des messages contenant les éléments suivants :

• WeightedPrompt: chaîne de texte décrivant une idée musicale, un genre, un instrument, une ambiance ou une caractéristique. Plusieurs requêtes peuvent être fournies pour mélanger les influences. Pour en savoir plus sur la meilleure façon de demander à Lyria RealTime, consultez la section ci-dessus.
• MusicGenerationConfig: configuration du processus de génération de musique, qui influence les caractéristiques de la sortie audio. Les paramètres incluent les éléments suivants :
  • guidance : (float) Plage : [0.0, 6.0]. Valeur par défaut : 4.0. Contrôle la rigueur avec laquelle le modèle suit les requêtes. Une guidance plus élevée améliore l'adhérence à la requête, mais rend les transitions plus abruptes.
  • bpm : (int) Plage : [60, 200]. Définit le nombre de battements par minute souhaité pour la musique générée. Vous devez arrêter/lire ou réinitialiser le contexte pour que le modèle prenne en compte le nouveau BPM.
  • density : (float) Plage : [0.0, 1.0]. Contrôle la densité des notes/sons musicaux. Les valeurs inférieures produisent une musique plus éparse, tandis que les valeurs supérieures produisent une musique plus "occupée".
  • brightness : (float) Plage : [0.0, 1.0]. Ajuste la qualité tonale. Des valeurs plus élevées produisent un son plus "brillant", en mettant généralement l'accent sur les fréquences plus élevées.
  • scale: (Enum) Définit la gamme musicale (clé et mode) pour la génération. Utilisez les Scale valeurs enum fournies par le SDK. Vous devez arrêter/lire ou réinitialiser le contexte pour que le modèle prenne en compte la nouvelle gamme.
  • mute_bass : (bool) Valeur par défaut : False. Contrôle si le modèle réduit les basses des sorties.
  • mute_drums : (bool) Valeur par défaut : False. Contrôle si le modèle réduit les percussions des sorties.
  • only_bass_and_drums : (bool) Valeur par défaut : False. Dirige le modèle pour qu'il n'essaie de générer que des basses et des percussions.
  • music_generation_mode: (Enum) Indique au modèle s'il doit se concentrer sur la QUALITY (valeur par défaut) ou la DIVERSITY de la musique. Il peut également être défini sur VOCALIZATION pour permettre au modèle de générer des vocalises comme un autre instrument (ajoutez-les en tant que nouvelles requêtes).
• PlaybackControl: commandes permettant de contrôler les aspects de la lecture, tels que la lecture, la pause, l'arrêt ou la réinitialisation du contexte.

Pour bpm, density, brightness et scale, si aucune valeur n'est fournie, le modèle décidera de ce qui est le mieux en fonction de vos requêtes initiales.

Des paramètres plus classiques tels que temperature (0,0 à 3,0, valeur par défaut 1,1), top_k (1 à 1 000, valeur par défaut 40) et seed (0 à 2 147 483 647, sélectionné de manière aléatoire par défaut) sont également personnalisables dans MusicGenerationConfig.

Valeurs enum de la gamme

Voici toutes les valeurs de gamme que le modèle peut accepter :

Le modèle est capable de guider les notes jouées, mais ne fait pas la distinction entre les clés relatives. Ainsi, chaque enum correspond à la fois au majeur et au mineur relatifs. Par exemple, C_MAJOR_A_MINOR correspond à toutes les touches blanches d'un piano, et F_MAJOR_D_MINOR correspond à toutes les touches blanches, sauf le si bémol.

Limites

• Instrumental uniquement : le modèle ne génère que de la musique instrumentale.
• Sécurité : les requêtes sont vérifiées par des filtres de sécurité. Les requêtes qui déclenchent les filtres seront ignorées. Dans ce cas, une explication sera écrite dans le champ filtered_prompt de la sortie.
• Filigrane : la sortie audio est toujours filigranée pour l'identification, conformément à nos principes d'IA responsable.

Étape suivante

• Générez des chansons complètes et des pistes vocales avec Lyria 3.
• Au lieu de la musique, découvrez comment générer une conversation à plusieurs locuteurs à l'aide de les modèles TTS.
• Découvrez comment générer des images ou des vidéos.
• Au lieu de générer de la musique ou de l'audio, découvrez comment Gemini peut comprendre les fichiers audio.
• Discutez en temps réel avec Gemini à l'aide de l' API Live.

Consultez le Cookbook pour obtenir d'autres exemples de code et tutoriels.