Gemini 3.8 Flash è ora disponibile. Mettiti alla prova.

Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Generare musica con Lyria 3.5

Lyria 3.5 è la famiglia di modelli di generazione di musica di Google, disponibile tramite l'API Gemini. Con Lyria 3.5 puoi generare audio stereo di alta qualità a 44,1 kHz a partire da prompt di testo o immagini. Questi modelli offrono coerenza strutturale, tra cui voci, testi sincronizzati e arrangiamenti strumentali completi.

La famiglia Lyria include i modelli:

Modello	ID modello	Ideale per	Durata	Output
Lyria 3 Clip	`lyria-3-clip-preview`	Clip corti, loop, anteprime	30 secondi	MP3
Lyria 3.5	`lyria-3.5`	Brani completi con strofe, ritornelli e ponti	Un paio di minuti (controllabile tramite prompt)	MP3

Entrambi i modelli possono essere utilizzati con la nuova API Interactions, supportano input multimodali (testo e immagini) e producono audio stereo ad alta fedeltà a 44,1 kHz.

Generare un clip musicale

Il modello Lyria 3 Clip genera sempre un clip di 30 secondi. Per generare un clip, chiama il metodo interactions.create con un prompt testuale. La risposta include sempre il testo e la struttura della canzone generati insieme all'audio nello schema steps.

Python

import base64
from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="lyria-3-clip-preview",
    input="A short instrumental acoustic guitar piece.",
)

generated_audio = interaction.output_audio
if generated_audio:
    with open("music.mp3", "wb") as f:
        f.write(base64.b64decode(generated_audio.data))

lyrics = interaction.output_text
if lyrics:
    print(f"Lyrics:\n{lyrics}")

JavaScript

import { GoogleGenAI } from '@google/genai';
import * as fs from 'fs';

const client = new GoogleGenAI({});

const interaction = await client.interactions.create({
    model: 'lyria-3-clip-preview',
    input: 'A short instrumental acoustic guitar piece.',
});

const generatedAudio = interaction.output_audio;
if (generatedAudio) {
  fs.writeFileSync('music.mp3', Buffer.from(generatedAudio.data, 'base64'));
}

const lyrics = interaction.output_text;
if (lyrics) {
  console.log(`Lyrics:\n${lyrics}`);
}

Java

import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.interactions.ResponseModality;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import java.util.Arrays;

Client client = new Client();

CreateModelInteraction params =
    CreateModelInteraction.builder()
        .model(Model.of("lyria-3-generate-001"))
        .responseModalities(Arrays.asList(ResponseModality.AUDIO))
        .input(InteractionsInput.of("Upbeat electronic synthwave track"))
        .build();

Interaction interaction =
    client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();

System.out.println("Audio generated: " + interaction.outputAudio().isPresent());

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{
    "model": "lyria-3-clip-preview",
    "input": "A short instrumental acoustic guitar piece."
}'

Puoi recuperare i dati musicali generati utilizzando la proprietà interaction.output_audio, che restituisce l'ultimo blocco audio generato. Puoi anche recuperare il testo e la struttura del brano utilizzando la proprietà interaction.output_text. Per informazioni dettagliate sulle proprietà di convenienza, consulta la panoramica delle interazioni.

Generare un brano completo

Utilizza il modello lyria-3.5 per generare brani di lunga durata che durano un paio di minuti. Il modello Pro comprende la struttura musicale e può creare composizioni con strofe, ritornelli e ponti distinti. Puoi influenzare la durata specificandola nel prompt (ad es. "crea una canzone di 2 minuti") o utilizzando timestamp per definire la struttura.

Python

interaction = client.interactions.create(
    model="lyria-3.5",
    input="An epic cinematic orchestral piece about a journey home. Starts with a solo piano intro, builds through sweeping strings, and climaxes with a massive wall of sound.",
)

JavaScript

const interaction = await client.interactions.create({
    model: 'lyria-3.5',
    input: 'A beautiful piano melody.',
});

Java

import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.interactions.ResponseModality;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import java.util.Arrays;

Client client = new Client();

CreateModelInteraction params =
    CreateModelInteraction.builder()
        .model(Model.of("lyria-3-generate-001"))
        .responseModalities(Arrays.asList(ResponseModality.AUDIO))
        .input(InteractionsInput.of("Upbeat electronic synthwave track"))
        .build();

Interaction interaction =
    client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();

System.out.println("Audio generated: " + interaction.outputAudio().isPresent());

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{
    "model": "lyria-3.5",
    "input": "A beautiful piano melody."
}'

Seleziona il formato di output

Per impostazione predefinita, i modelli Lyria 3.5 generano audio in formato MP3. Per Lyria 3.5, puoi anche richiedere l'output in formato WAV impostando response_format.

Python

interaction = client.interactions.create(
    model="lyria-3.5",
    input="A beautiful piano melody.",
    response_format={"type": "audio"},
)

JavaScript

const interaction = await client.interactions.create({
    model: 'lyria-3.5',
    input: 'A beautiful piano melody.',
    response_format: {
        type: 'audio',
    },
});

Java

import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.interactions.ResponseModality;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import java.util.Arrays;

Client client = new Client();

CreateModelInteraction params =
    CreateModelInteraction.builder()
        .model(Model.of("lyria-3-generate-001"))
        .responseModalities(Arrays.asList(ResponseModality.AUDIO))
        .input(InteractionsInput.of("Upbeat electronic synthwave track"))
        .build();

Interaction interaction =
    client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();

System.out.println("Audio generated: " + interaction.outputAudio().isPresent());

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "lyria-3.5",
    "input": "A beautiful piano melody.",
    "response_format": {
        "type": "audio"
    }
  }'

Analizza la risposta

La risposta di Lyria 3.5 contiene più blocchi di contenuti all'interno dello schema steps. Le interazioni restituiscono una sequenza di passaggi, in cui i passaggi model_output contengono i contenuti generati. I blocchi di contenuti di testo contengono i testi generati o una descrizione JSON della struttura del brano. I blocchi di contenuti di tipo audio contengono i dati audio codificati in base64.

Python

lyrics = []
audio_data = None

generated_audio = interaction.output_audio
if generated_audio:
    with open("output.mp3", "wb") as f:
        f.write(base64.b64decode(generated_audio.data))

lyrics = interaction.output_text
if lyrics:
    print(f"Lyrics:\n{lyrics}")

JavaScript

const lyrics = [];
let audioData = null;

const generatedAudio = interaction.output_audio;
if (generatedAudio) {
    fs.writeFileSync("output.mp3", Buffer.from(generatedAudio.data, 'base64'));
}

const lyrics = interaction.output_text;
if (lyrics) {
    console.log("Lyrics:\n" + lyrics);
}

Java

import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.interactions.ResponseModality;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import java.util.Arrays;

Client client = new Client();

CreateModelInteraction params =
    CreateModelInteraction.builder()
        .model(Model.of("lyria-3-generate-001"))
        .responseModalities(Arrays.asList(ResponseModality.AUDIO))
        .input(InteractionsInput.of("Upbeat electronic synthwave track"))
        .build();

Interaction interaction =
    client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();

System.out.println("Audio generated: " + interaction.outputAudio().isPresent());

REST

# The output from the REST API is a JSON object containing base64 encoded data.
# You can extract the text or the audio data using a tool like jq.
# To extract the audio and save it to a file:
curl ... | jq -r '.steps[] | select(.type=="model_output") | .content[] | select(.type=="audio") | .data' | base64 -d > output.mp3

Testi e musica alternati

Poiché l'output di Lyria 3.5 è complesso e contiene passaggi e blocchi separati per i testi generati (testo) e il brano stesso (audio), le proprietà di convenienza offrono una scorciatoia rapida e consigliata.

Tuttavia, se vuoi un controllo programmatico completo sulla sequenza temporale non elaborata dei passaggi restituiti dal server (ad esempio, registrando i singoli blocchi di contenuti man mano che vengono ricevuti), puoi eseguire l'iterazione manualmente su steps:

Python

lyrics = []
audio_data = None

for step in interaction.steps:
    if step.type == "model_output":
        for content_block in step.content:
            if content_block.type == "audio":
                audio_data = base64.b64decode(content_block.data)
            elif content_block.type == "text":
                lyrics.append(content_block.text)

if lyrics:
    print("Lyrics:\n" + "\n".join(lyrics))

if audio_data:
    with open("output.mp3", "wb") as f:
        f.write(audio_data)

JavaScript

const lyrics = [];
let audioData = null;

for (const step of interaction.steps) {
    if (step.type === 'model_output') {
        for (const contentBlock of step.content) {
            if (contentBlock.type === 'audio') {
                audioData = Buffer.from(contentBlock.data, 'base64');
            } else if (contentBlock.type === 'text') {
                lyrics.push(contentBlock.text);
            }
        }
    }
}

if (lyrics.length) {
    console.log("Lyrics:\n" + lyrics.join("\n"));
}

if (audioData) {
    fs.writeFileSync("output.mp3", audioData);
}

Java

import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.interactions.ResponseModality;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import java.util.Arrays;

Client client = new Client();

CreateModelInteraction params =
    CreateModelInteraction.builder()
        .model(Model.of("lyria-3-generate-001"))
        .responseModalities(Arrays.asList(ResponseModality.AUDIO))
        .input(InteractionsInput.of("Upbeat electronic synthwave track"))
        .build();

Interaction interaction =
    client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();

System.out.println("Audio generated: " + interaction.outputAudio().isPresent());

Generare musica dalle immagini

Lyria 3.5 supporta input multimodali: puoi fornire fino a 10 immagini insieme al prompt testuale nell'elenco input e il modello comporrà musica ispirata ai contenuti visivi.

Python

import base64

with open("desert_sunset.jpg", "rb") as f:
    image_bytes = f.read()
    image_b64 = base64.b64encode(image_bytes).decode("utf-8")

response = client.interactions.create(
    model="lyria-3.5",
    input=[
        {
            "type": "text",
            "text": "An atmospheric ambient track inspired by the mood and colors in this image.",
        },
        {
            "type": "image",
            "mime_type": "image/jpeg",
            "data": image_b64,
        },
    ],
)

JavaScript

import * as fs from "fs";

const imageBytes = fs.readFileSync("desert_sunset.jpg").toString("base64");

const interaction = await client.interactions.create({
    model: "lyria-3.5",
    input: [
        {
            type: "text",
            text: "An atmospheric ambient track inspired by the mood and colors in this image.",
        },
        {
            type: "image",
            mime_type: "image/jpeg",
            data: imageBytes,
        },
    ],
});

Java

import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.interactions.ResponseModality;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import java.util.Arrays;

Client client = new Client();

CreateModelInteraction params =
    CreateModelInteraction.builder()
        .model(Model.of("lyria-3-generate-001"))
        .responseModalities(Arrays.asList(ResponseModality.AUDIO))
        .input(InteractionsInput.of("Upbeat electronic synthwave track"))
        .build();

Interaction interaction =
    client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();

System.out.println("Audio generated: " + interaction.outputAudio().isPresent());

REST

# Pass base64 encoded image data directly:
curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "lyria-3.5",
    "input": [
      {"type": "text", "text": "An atmospheric ambient track inspired by the mood and colors in this image."},
      {"type": "image", "mime_type": "image/jpeg", "data": "/9j/4AAQSkZJRgABAQEASABIAAD/2wBDAP//////////////////////////////////////////////////////////////////////////////////////wgALCAABAAEBAREA/8QAFBABAAAAAAAAAAAAAAAAAAAAAP/aAAgBAQABPxA="}
    ]
  }'

Fornire testi personalizzati

Puoi scrivere i tuoi testi e includerli nel prompt. Utilizza i tag di sezione come [Verse], [Chorus] e [Bridge] per aiutare il modello a comprendere la struttura del brano:

Python

prompt = """
Create a dreamy indie pop song with the following lyrics:

[Verse 1]
Walking through the neon glow,
city lights reflect below,
every shadow tells a story,
every corner, fading glory.

[Chorus]
We are the echoes in the night,
burning brighter than the light,
hold on tight, don't let me go,
we are the echoes down below.

[Verse 2]
Footsteps lost on empty streets,
rhythms sync to heartbeats,
whispers carried by the breeze,
dancing through the autumn leaves.
"""

interaction = client.interactions.create(
    model="lyria-3.5",
    input=prompt,
)

JavaScript

const prompt = `
Create a dreamy indie pop song with the following lyrics:

[Verse 1]
Walking through the neon glow,
city lights reflect below,
every shadow tells a story,
every corner, fading glory.

[Chorus]
We are the echoes in the night,
burning brighter than the light,
hold on tight, don't let me go,
we are the echoes down below.

[Verse 2]
Footsteps lost on empty streets,
rhythms sync to heartbeats,
whispers carried by the breeze,
dancing through the autumn leaves.
`;

const interaction = await client.interactions.create({
    model: 'lyria-3.5',
    input: prompt,
});

Java

import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.interactions.ResponseModality;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import java.util.Arrays;

Client client = new Client();

CreateModelInteraction params =
    CreateModelInteraction.builder()
        .model(Model.of("lyria-3-generate-001"))
        .responseModalities(Arrays.asList(ResponseModality.AUDIO))
        .input(InteractionsInput.of("Upbeat electronic synthwave track"))
        .build();

Interaction interaction =
    client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();

System.out.println("Audio generated: " + interaction.outputAudio().isPresent());

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "lyria-3.5",
    "input": "Create a dreamy indie pop song with the following lyrics: ..."
  }'

Controllare la tempistica e la struttura

Puoi specificare esattamente cosa succede in momenti specifici del brano utilizzando i timestamp. Questo è utile per controllare quando entrano gli strumenti, quando vengono fornite le parole e come procede la canzone:

Python

prompt = """
[0:00 - 0:10] Intro: Begin with a soft lo-fi beat and muffled
              vinyl crackle.
[0:10 - 0:30] Verse 1: Add a warm Fender Rhodes piano melody
              and gentle vocals singing about a rainy morning.
[0:30 - 0:50] Chorus: Full band with upbeat drums and soaring
              synth leads. The lyrics are hopeful and uplifting.
[0:50 - 1:00] Outro: Fade out with the piano melody alone.
"""

interaction = client.interactions.create(
    model="lyria-3.5",
    input=prompt,
)

JavaScript

const prompt = `
[0:00 - 0:10] Intro: Begin with a soft lo-fi beat and muffled
              vinyl crackle.
[0:10 - 0:30] Verse 1: Add a warm Fender Rhodes piano melody
              and gentle vocals singing about a rainy morning.
[0:30 - 0:50] Chorus: Full band with upbeat drums and soaring
              synth leads. The lyrics are hopeful and uplifting.
[0:50 - 1:00] Outro: Fade out with the piano melody alone.
`;

const interaction = await client.interactions.create({
    model: 'lyria-3.5',
    input: prompt,
});

Java

import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.interactions.ResponseModality;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import java.util.Arrays;

Client client = new Client();

CreateModelInteraction params =
    CreateModelInteraction.builder()
        .model(Model.of("lyria-3-generate-001"))
        .responseModalities(Arrays.asList(ResponseModality.AUDIO))
        .input(InteractionsInput.of("Upbeat electronic synthwave track"))
        .build();

Interaction interaction =
    client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();

System.out.println("Audio generated: " + interaction.outputAudio().isPresent());

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "lyria-3.5",
    "input": "[0:00 - 0:10] Intro: ..."
  }'

Generare tracce strumentali

Per la musica di sottofondo, le colonne sonore dei giochi o qualsiasi caso d'uso in cui non sono richieste parti vocali, puoi chiedere al modello di produrre tracce solo strumentali:

Python

interaction = client.interactions.create(
    model="lyria-3-clip-preview",
    input="A bright chiptune melody in C Major, retro 8-bit video game style. Instrumental only, no vocals.",
)

JavaScript

const interaction = await client.interactions.create({
    model: 'lyria-3-clip-preview',
    input: 'A bright chiptune melody in C Major, retro 8-bit video game style. Instrumental only, no vocals.',
});

Java

import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.interactions.ResponseModality;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import java.util.Arrays;

Client client = new Client();

CreateModelInteraction params =
    CreateModelInteraction.builder()
        .model(Model.of("lyria-3-generate-001"))
        .responseModalities(Arrays.asList(ResponseModality.AUDIO))
        .input(InteractionsInput.of("Upbeat electronic synthwave track"))
        .build();

Interaction interaction =
    client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();

System.out.println("Audio generated: " + interaction.outputAudio().isPresent());

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "lyria-3-clip-preview",
    "input": "A bright chiptune melody in C Major, retro 8-bit video game style. Instrumental only, no vocals."
  }'

Generare musica in lingue diverse

Lyria 3.5 genera testi nella lingua del prompt. Per generare una canzone con un testo in francese, scrivi il prompt in francese. Il modello adatta lo stile vocale e la pronuncia in base alla lingua.

Python

interaction = client.interactions.create(
    model="lyria-3.5",
    input="Crée une chanson pop romantique en français sur un coucher de soleil à Paris. Utilise du piano et de la guitare acoustique.",
)

JavaScript

const interaction = await client.interactions.create({
    model: 'lyria-3.5',
    input: 'Crée une chanson pop romantique en français sur un coucher de soleil à Paris. Utilise du piano et de la guitare acoustique.',
});

Java

import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.interactions.ResponseModality;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import java.util.Arrays;

Client client = new Client();

CreateModelInteraction params =
    CreateModelInteraction.builder()
        .model(Model.of("lyria-3-generate-001"))
        .responseModalities(Arrays.asList(ResponseModality.AUDIO))
        .input(InteractionsInput.of("Upbeat electronic synthwave track"))
        .build();

Interaction interaction =
    client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();

System.out.println("Audio generated: " + interaction.outputAudio().isPresent());

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "lyria-3.5",
    "input": "Crée une chanson pop romantique en français sur un coucher de soleil à Paris. Utilise du piano et de la guitare acoustique."
  }'

Intelligenza del modello

Lyria 3.5 analizza il processo di prompt in cui il modello ragiona sulla struttura musicale (intro, strofa, ritornello, bridge e così via) in base al prompt. Ciò avviene prima della generazione dell'audio e garantisce coerenza strutturale e musicalità.

Guida ai prompt

Il prompt può essere semplice come "una canzone folk su gatti carini che evitano le pozzanghere, voce femminile e rumore della pioggia" oppure qualcosa di dettagliato e strutturato come:

Un brano synth-pop in stile anni '80 con un ritmo incalzante, sintetizzatori brillanti e un ritornello orecchiabile e trascinante. La canzone deve avere un'atmosfera retro-futuristica, che ricorda i classici successi pop degli anni '80, con un tocco di modernità. Il tempo deve essere allegro e ballabile, intorno ai 120 BPM, con una chiara struttura strofa-ritornello e un hook strumentale memorabile. Il testo parla della sensazione di prepararsi per una festa.

Prompt semplici e complessi possono fornire buoni risultati. Sperimenta con questi suggerimenti per trovare la soluzione più adatta a te.

Genere

Inizia il prompt con il genere musicale che preferisci, ad esempio hip hop, rock e rap. Puoi specificare un mix di generi:

Una fusione di metal e rap
Una combinazione di death metal e opera
Un brano classico con elementi di droni elettronici
Musica dance elettronica (EDM) moderna mixata con Europop

Puoi anche incorporare un'era:

Hip hop dei primi anni '90
Pop ye-ye francese degli anni '60
Sperimentazione elettronica anni '80
Pop mainstream degli anni 2000

Se richiedi generi personalizzati o varianti regionali, come "techno berlinese" o "hyphy della Bay Area", il modello tenterà di catturare l'essenza, ma potrebbe non riuscirci sempre.

Strumenti

Per impostazione predefinita, Lyria 3.5 crea brani con gli strumenti che ti aspetteresti per il genere. Non è necessario essere prescrittivi.

Tuttavia, una traccia dance non includerà un sassofono a meno che tu non lo chieda. Quindi, se vuoi un assolo di sassofono, devi richiederlo:

Una traccia dance con un ritmo incalzante, sintetizzatori scintillanti e un ritornello orecchiabile che fa venire voglia di cantare. Durante il bridge deve entrare un assolo di sassofono.

Il prompt può includere strumenti specifici, il loro suono e il modo in cui interagiscono tra loro. Puoi utilizzare questa combinazione per creare determinati stati d'animo o texture:

Una linea di basso sporca e distorta che contrasta con hi-hat puliti e nitidi
Pad di sintetizzatore analogico caldi che si gonfiano sotto una chitarra acustica secca e intima
Un muro di suono creato da più livelli di chitarre fuzz, con voci lontane e sepolte

Struttura del brano

Puoi descrivere la progressione di un brano nel prompt. Utilizza le frecce o un elenco per definire il flusso:

[Intro] -> [Verse 1] -> [Chorus] -> [Verse 2] -> [Chorus] -> [Bridge] -> [Outro]
Inizia con un intro di pianoforte tranquillo, passa a una strofa potente, poi a un silenzio e infine esplodi nel ritornello.

Puoi anche specificare come cambiano i livelli di energia tra queste sezioni:

Crea tensione nel pre-chorus, poi passa al silenzio prima di un chorus massiccio ed esplosivo
Crescendo graduale durante il brano, con l'aggiunta di uno strumento alla volta fino a un muro di suono caotico
Interruzione improvvisa dopo il ponte, seguita da un coro a cappella

Puoi anche richiedere l'ora esatta in cui vuoi che accada qualcosa:

Crea un drop a 12 secondi
Qualcuno dice "cosa" ogni 2 secondi
Il ritornello inizia a 22 secondi

Testo

La voce e i testi vengono generati per impostazione predefinita. Puoi fornire i tuoi testi, richiedere di non includere testi (o una versione strumentale) o indirizzare la generazione dei testi nella direzione che preferisci.

I testi saranno nella lingua in cui scrivi il prompt. Puoi anche chiedere che il testo sia in un'altra lingua, ad esempio "Scrivi il testo in francese".

Utilizzo dei propri testi

Per fornire al modello i tuoi testi, includili nel prompt con il prefisso "Lyrics:":

Lyrics:

[Intro]
Oooh, oooh

[Verse 1]
Let's go
Let's go
Go with the flow

[Chorus]
...

Puoi aggiungere un prefisso alle parti del brano con titoli di sezione come [Intro], [Verse 1], [Pre-chorus], [Chorus] e [Outro].

Se vuoi che una parola o una riga venga ripetuta, come un eco o dai coristi, puoi includerla tra parentesi: "Let's go (go)".

Chiedere al modello di scrivere i testi

Se vuoi che Lyria 3.5 crei i testi per te, è meglio includere dettagli su cosa tratteranno i testi nel prompt. In caso contrario, il modello deve dedurre un soggetto dal prompt musicale e potrebbe non essere quello che vuoi.

Il testo parla di un amore perduto e del dolore di una delusione amorosa. Il cantante sta ricordando una relazione passata e i ricordi che gli tornano in mente.

Se vuoi un ritornello ripetuto, è utile chiederlo nel prompt:

Il testo parla di un amore perduto e del dolore di una delusione amorosa. Il cantante sta ricordando una relazione passata e i ricordi che gli tornano in mente. Un ritornello potente si concentra sul superamento del dolore e sul voltare pagina.

Lyria 3.5 indirizzerà automaticamente la struttura del testo verso il tipo di musica che stai richiedendo, ma puoi riaffermarlo anche nel prompt. Ad esempio:

Un brano di musica elettronica che ripete la stessa frase energica più e più volte.

Puoi anche richiedere effetti vocali che non sono strettamente testi, ad esempio:

Un campione ripetuto di un film dice "Non ci posso credere!" per tutta la durata della canzone
Un brano techno ad alta energia, proprio prima del drop la musica si interrompe e una vocina dice "Non so cosa ci faccio qui", poi la musica riprende.
La traccia si apre con una conversazione sui film degli anni '90 che erano migliori di quelli di oggi. Poi la traccia si trasforma in un brano pop.

Voce

Puoi specificare come vuoi che vengano forniti i testi. Per ottenere i risultati migliori, specifica un profilo dettagliato del cantante che includa genere, timbro ed estensione vocale.

Soprano femminile: timbro chiaro e cristallino con una qualità agile e impetuosa. Capace di raggiungere note alte e fischiettanti con una consistenza ariosa e soffice.
Contralto femminile: gamma bassa ricca, calda e rauca. Timbro fumoso con un tocco di vocal fry, pieno di anima e risonante.
Tenore maschile: brillante, penetrante ed energico. Timbro giovanile con una leggera sfumatura nasale, che si distingue nel mix con una potenza vocale elevata.
Baritono maschile: profondo, cioccolatoso e vellutato. Voce profonda con un tono dolce e melodioso.
Weathered Rocker (uomo): voce roca e ruvida con un timbro granuloso, che ricorda il grunge degli anni '90. Gamma superiore tesa per l'intensità emotiva.

Altri parametri del prompt

Puoi anche includere questi parametri per perfezionare ulteriormente il prompt:

BPM: imposta il tempo (ad es. "120 BPM", "tempo lento intorno a 70 BPM").
Tonalità/Scala: specifica una tonalità musicale (ad es. "in sol maggiore", "re minore").
Stato d'animo e atmosfera: utilizza aggettivi descrittivi (ad es. "nostalgico", "aggressivo", "etereo", "onirico").
Durata: il modello Clip produce sempre clip di 30 secondi. Per il modello Pro, specifica la durata desiderata nel prompt (ad es. "crea una canzone di 2 minuti") o utilizza i timestamp per controllare la durata.

Prompt di esempio

Ecco alcuni esempi di prompt efficaci:

"A 30-second lofi hip hop beat with dusty vinyl crackle, mellow Rhodes piano chords, a slow boom-bap drum pattern at 85 BPM, and a jazzy upright bass line. Instrumental only."
"An upbeat, feel-good pop song in G major at 120 BPM with bright acoustic guitar strumming, claps, and warm vocal harmonies about a summer road trip."
"A dark, atmospheric trap beat at 140 BPM with heavy 808 bass, eerie synth pads, sharp hi-hats, and a haunting vocal sample. In D minor."

Best practice

Esegui l'iterazione con Clip. Utilizza il modello lyria-3-clip-preview più veloce per sperimentare con i prompt prima di eseguire una generazione completa con lyria-3.5.
Usa un testo specifico. I prompt vaghi producono risultati generici. Menziona strumenti, BPM, tonalità, stato d'animo e struttura per ottenere il miglior output.
Scegli la tua lingua. Prompt nella lingua in cui vuoi che vengano visualizzati i testi.
Utilizza i tag di sezione. I tag [Verse], [Chorus] e [Bridge] forniscono al modello una struttura chiara da seguire.
Separa i testi dalle istruzioni. Quando fornisci testi personalizzati, separali chiaramente dalle istruzioni per la direzione musicale.

Limitazioni

Sicurezza: tutti i prompt vengono controllati dai filtri di sicurezza. I prompt che attivano i filtri verranno bloccati. Ciò include i prompt che richiedono voci di artisti specifici o la generazione di testi protetti da copyright.
Filigrana: tutto l'audio generato include una filigrana audio SynthID per l'identificazione. Questa filigrana è impercettibile all'orecchio umano e non influisce sull'esperienza di ascolto.
Modifica multi-turno: la generazione di musica è un processo in un solo passaggio. L'editing iterativo o il perfezionamento di un clip generato tramite più prompt non è supportato nella versione attuale di Lyria 3.5.
Durata: il modello Clip genera sempre clip di 30 secondi. Il modello Pro genera brani che durano un paio di minuti; la durata esatta può essere influenzata dal prompt.
Determinismo: i risultati possono variare tra le chiamate, anche con lo stesso prompt.

Passaggi successivi

Consulta i prezzi dei modelli Lyria 3.5.
Prova la generazione di musica in streaming in tempo reale con Lyria RealTime.
Genera conversazioni con più interlocutori con i modelli TTS.
Scopri come generare immagini o video.
Scopri come Gemini può comprendere i file audio.
Avvia una conversazione in tempo reale con Gemini utilizzando l'API Live.