Génération de musique 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 de pointe. Il 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.

Pour découvrir ce que vous pouvez créer avec Lyria RealTime, essayez-le dans AI Studio à l'aide des applications Prompt DJ ou MIDI DJ.

Fonctionnement de la génération de musique

La génération de musique en temps réel Lyria utilise une connexion de streaming persistante, bidirectionnelle et à faible latence à l'aide de WebSocket.

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

Lyria RealTime fonctionne un peu comme l'API Live, dans le sens où elle utilise des WebSockets pour maintenir une communication en temps réel avec le modèle. Ce n'est toujours pas exactement la même chose, car vous ne pouvez pas parler au modèle et vous devez utiliser un format spécifique pour l'interroger.

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, suspendre, arrêter ou réinitialiser la session.

Diriger la musique en temps réel

Inviter Lyria RealTime

Tant que la diffusion est active, vous pouvez envoyer de nouveaux messages WeightedPrompt à tout moment pour modifier la musique générée. Le modèle effectuera une transition fluide 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. weight peut prendre n'importe quelle valeur, sauf 0. 1.0 constitue généralement un bon point de départ.

  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 invites. 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 également modifier 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 sur leurs valeurs par défaut.

Étant donné que la mise à jour du BPM ou de la gamme est un changement radical pour le modèle, vous devrez également lui demander de réinitialiser son contexte à l'aide de reset_context() pour prendre en compte la nouvelle configuration. La diffusion ne s'arrêtera pas, mais la transition sera brutale. Vous n'avez pas besoin de le faire pour les autres paramètres.

  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 des requêtes pour Lyria RealTime

Voici une liste non exhaustive de requêtes que vous pouvez utiliser pour solliciter 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, ...
• Humeur/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. Testez vos propres requêtes !

Bonnes pratiques

• Les applications clientes doivent implémenter une mise en mémoire tampon audio robuste pour assurer une lecture fluide. Cela permet de tenir compte des fluctuations du réseau et des légères variations de la latence de génération.
• Formuler des requêtes efficaces :
  • Misez sur la description. Utilisez des adjectifs décrivant l'ambiance, le genre et l'instrumentation.
  • Itérez et ajustez progressivement. Plutôt que de modifier complètement le prompt, essayez d'ajouter ou de modifier des éléments pour transformer la musique plus facilement.
  • Testez le poids sur WeightedPrompt pour influencer l'impact d'un nouveau prompt sur 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 en temps réel Lyria.

Spécifications

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

Commandes

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

• 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 savoir comment formuler au mieux vos requêtes à Lyria RealTime, consultez les informations ci-dessus.
• MusicGenerationConfig : configuration du processus de génération de musique, qui influe sur les caractéristiques de la sortie audio. Voici quelques exemples de paramètres :
  • 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 valeur de guidance plus élevée améliore l'adhérence au prompt, 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 du modèle pour qu'il prenne en compte le nouveau BPM.
  • density : (float) Plage : [0.0, 1.0]. Contrôle la densité des notes/sons musicaux. Des valeurs plus faibles produisent une musique plus clairsemée, tandis que des valeurs plus élevées produisent une musique plus "chargée".
  • brightness : (float) Plage : [0.0, 1.0]. Ajuste la qualité tonale. Des valeurs plus élevées produisent un son plus "clair", en mettant généralement l'accent sur les fréquences plus élevées.
  • scale : (Enum) définit la gamme musicale (tonalité et mode) pour la génération. Utilisez les valeurs d'énumération Scale fournies par le SDK. Vous devez arrêter/lire ou réinitialiser le contexte pour que le modèle prenne en compte la nouvelle échelle.
  • mute_bass : (booléen) par défaut : False. Contrôle si le modèle réduit les basses des sorties.
  • mute_drums : (booléen) par défaut : False. Détermine si la sortie du modèle réduit la batterie.
  • only_bass_and_drums : (booléen) par défaut : False. Orientez le modèle pour qu'il ne génère que la basse et la batterie.
  • music_generation_mode : (Enum) indique au modèle s'il doit se concentrer sur QUALITY (valeur par défaut) ou 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 nouveaux pompts).
• PlaybackControl : commandes permettant de contrôler la lecture (lecture, pause, arrêt ou réinitialisation du contexte, par exemple).

Pour bpm, density, brightness et scale, si aucune valeur n'est fournie, le modèle choisira la meilleure option en fonction de vos requêtes initiales.

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

Valeurs enum de l'échelle

Voici toutes les valeurs d'échelle 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 tonalités relatives. Ainsi, chaque énumération correspond à la fois à la version majeure et à la version mineure relatives. Par exemple, C_MAJOR_A_MINOR correspond à toutes les touches blanches d'un piano, et F_MAJOR_D_MINOR à 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 déclenchant les filtres seront ignorées. Dans ce cas, une explication sera fournie dans le champ filtered_prompt de la sortie.
• Filigranes : les données audio générées sont toujours filigranées pour être identifiées, conformément à nos principes d'IA responsable.

Étape suivante

• Au lieu de la musique, découvrez comment générer une conversation entre plusieurs locuteurs à l'aide des 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.