Gemini 3.8 Flash jest już dostępny. Przećwicz to samodzielnie.

Google używa technologii AI do tłumaczenia treści na Twój preferowany język. Tłumaczenia wygenerowane przez AI mogą zawierać błędy.

Generowanie muzyki za pomocą Lyrii 3.5

Lyria 3.5 to rodzina modeli generowania muzyki od Google, dostępna w ramach Gemini API. Dzięki Lyrii 3.5 możesz generować wysokiej jakości dźwięk stereo o częstotliwości 44,1 kHz na podstawie promptów tekstowych lub obrazów. Te modele zapewniają spójność strukturalną, w tym wokal, zsynchronizowany tekst i pełne aranżacje instrumentalne.

Rodzina Lyria obejmuje modele:

Model	Identyfikator modelu	Urządzenia	Czas trwania	Wyniki
Lyria 3 Clip	`lyria-3-clip-preview`	Krótkie klipy, pętle, podglądy	30 sekund	MP3
Lyria 3.5	`lyria-3.5`	pełne utwory z wersami, refrenami i przejściami;	Kilka minut (można kontrolować za pomocą prompta)	MP3

Oba modele można używać za pomocą nowego interfejsu API Interactions, który obsługuje dane wejściowe multimodalne (tekst i obrazy) i generuje stereofoniczny dźwięk o wysokiej jakości (44,1 kHz).

Generowanie klipu muzycznego

Model Lyria 3 Clip zawsze generuje 30-sekundowy klip. Aby wygenerować klip, wywołaj metodę interactions.create z promptem tekstowym. Odpowiedź zawsze zawiera wygenerowane słowa i strukturę utworu wraz z dźwiękiem w schemacie 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."
}'

Wygenerowane dane muzyczne możesz pobrać za pomocą właściwości interaction.output_audio, która zwraca ostatni wygenerowany blok audio. Możesz też pobrać tekst i strukturę utworu za pomocą właściwości interaction.output_text. Szczegółowe informacje o właściwościach ułatwiających korzystanie z interfejsu znajdziesz w omówieniu interakcji.

Generowanie pełnych utworów

Użyj modelu lyria-3.5, aby wygenerować pełne utwory trwające kilka minut. Model Pro rozumie strukturę muzyczną i może tworzyć kompozycje z wyraźnymi zwrotkami, refrenami i przejściami. Możesz wpłynąć na czas trwania utworu, podając go w prompcie (np. „utwórz 2-minutową piosenkę”) lub używając sygnatur czasowych do zdefiniowania struktury.

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."
}'

Wybierz format wyjściowy

Domyślnie modele Lyria 3.5 generują dźwięk w formacie MP3. W przypadku Lyrii 3.5 możesz też poprosić o wygenerowanie danych wyjściowych w formacie WAV, ustawiając parametr 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"
    }
  }'

Analizowanie odpowiedzi

Odpowiedź z Lyrii 3.5 zawiera wiele bloków treści w schemacie steps. Interakcje zwracają sekwencję kroków, w której kroki model_output zawierają wygenerowane treści. Bloki treści tekstowych zawierają wygenerowane teksty lub opis struktury utworu w formacie JSON. Bloki treści typu audio zawierają dane audio zakodowane w formacie 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

Tekst i muzyka przeplatają się

Dane wyjściowe Lyrii 3.5 są złożone – zawierają osobne kroki i bloki wygenerowanych tekstów (tekst) oraz sam utwór (audio). Właściwości wygody oferują szybki i zalecany skrót.

Jeśli jednak chcesz mieć pełną, programową kontrolę nad surową osią czasu kroków zwracanych przez serwer (np. rejestrować poszczególne bloki treści w miarę ich otrzymywania), możesz ręcznie iterować po 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());

Generowanie muzyki na podstawie obrazów

Lyria 3.5 obsługuje dane wejściowe w różnych formatach – możesz podać maksymalnie 10 obrazów wraz z promptem tekstowym na liście input, a model skomponuje muzykę inspirowaną treściami wizualnymi.

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="}
    ]
  }'

Podaj własny tekst

Możesz napisać własne teksty i uwzględnić je w prompcie. Używaj tagów sekcji, takich jak [Verse], [Chorus] i [Bridge], aby pomóc modelowi zrozumieć strukturę utworu:

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: ..."
  }'

Kontrolowanie czasu i struktury

Za pomocą sygnatur czasowych możesz określić, co ma się dziać w konkretnych momentach utworu. Jest to przydatne do kontrolowania, kiedy wchodzą instrumenty, kiedy pojawiają się słowa i jak rozwija się utwór:

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: ..."
  }'

Generowanie ścieżek instrumentalnych

W przypadku muzyki w tle, ścieżek dźwiękowych do gier lub innych zastosowań, w których nie są wymagane wokale, możesz poprosić model o wygenerowanie utworów instrumentalnych:

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."
  }'

Generowanie muzyki w różnych językach

Lyria 3.5 generuje tekst w języku prompta. Aby wygenerować utwór z tekstem w języku francuskim, wpisz prompta w tym języku. Model dostosowuje styl głosu i wymowę do języka.

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."
  }'

Inteligentne modele

Lyria 3.5 analizuje proces promptowania, w którym model wnioskuje na podstawie prompta o strukturze muzycznej (wstęp, zwrotka, refren, mostek itp.). Dzieje się to przed wygenerowaniem dźwięku i zapewnia spójność strukturalną oraz muzykalność.

Przewodnik po promptach

Prompt może być tak prosty jak „piosenka folkowa o słodkich kotach unikających kałuż, śpiewana przez kobietę, z odgłosami deszczu” lub bardziej szczegółowy i złożony, np.:

Utwór synth-pop w stylu lat 80. z dynamicznym rytmem, mieniącymi się syntezatorami i chwytliwym, hymnicznym refrenem. Utwór powinien mieć retro-futurystyczny charakter, przypominający klasyczne hity pop z lat 80., ale z nowoczesną produkcją. Tempo powinno być szybkie i zachęcające do tańca, około 120 uderzeń na minutę, z wyraźną strukturą zwrotka–refren i zapamiętywalnym instrumentalnym motywem. Tekst opowiada o przygotowaniach do imprezy.

Zarówno proste, jak i złożone prompty mogą dać dobre wyniki. Wypróbuj te wskazówki, aby znaleźć najlepsze rozwiązanie dla siebie.

Gatunek

Zacznij prompt od gatunku muzyki, np. hip-hop, rock i rap. Możesz określić mieszankę gatunków:

Połączenie metalu i rapu
Połączenie death metalu i opery
Klasyczny utwór z elementami elektronicznymi
Nowoczesna elektroniczna muzyka taneczna (EDM) zmiksowana z europopem

Możesz też uwzględnić epokę:

Hip-hop z początku lat 90.
Francuski pop ye-ye z lat 60.
Eksperymenty z elektroniką w latach 80.
Pop głównego nurtu z pierwszej dekady XXI w.

Jeśli poprosisz o określone gatunki lub regionalne odmiany, takie jak „techno z Berlina” lub „hyphy z Bay Area”, model spróbuje uchwycić ich istotę, ale nie zawsze mu się to uda.

Instrumenty

Domyślnie Lyria 3.5 tworzy utwory z instrumentami i narzędziami, których można się spodziewać w danym gatunku. Nie musisz być zbyt szczegółowy.

Jednak utwór taneczny nie będzie zawierał saksofonu, chyba że o to poprosisz. Jeśli chcesz, aby w utworze pojawiła się partia solowa saksofonu, musisz to zaznaczyć w prompcie:

Utwór taneczny z mocnym rytmem, błyszczącymi syntezatorami i chwytliwym, hymnicznym refrenem. Podczas bridge’a powinno pojawić się solo na saksofonie.

Prompt może zawierać konkretne instrumenty, sposób ich brzmienia i wzajemne interakcje. Możesz użyć tej kombinacji, aby stworzyć określony nastrój lub teksturę:

Brudna, zniekształcona linia basu walcząca z czystymi, wyrazistymi hi-hatami
Ciepłe, analogowe syntezatory rozbrzmiewające pod suchą, intymną gitarą akustyczną
Ściana dźwięku stworzona przez wiele warstw przesterowanych gitar z ukrytym, odległym wokalem

Struktura utworu

W prompcie możesz opisać progresję utworu. Aby zdefiniować przepływ, użyj strzałek lub listy:

[Intro] -> [Verse 1] -> [Chorus] -> [Verse 2] -> [Chorus] -> [Bridge] -> [Outro]
Zacznij od cichego intra na pianinie, przejdź do głośnej zwrotki, wycisz utwór, a następnie przejdź do refrenu.

Możesz też określić, jak zmienia się poziom energii między tymi sekcjami:

Buduj napięcie w prechorusie, a potem wycisz utwór przed potężnym, wybuchowym refrenem.
Stopniowe crescendo w całym utworze, dodawanie po jednym instrumencie, aż do chaotycznej ściany dźwięku.
Nagłe zatrzymanie po moście, a następnie chór a cappella

Możesz też podać dokładną godzinę, o której ma się coś wydarzyć:

Budowanie napięcia do momentu spadku po 12 sekundach
Ktoś co 2 sekundy mówi „co”
Refren zaczyna się w 22 sekundzie

Tekst

Wokale i teksty są generowane domyślnie. Możesz podać własne teksty, poprosić o brak tekstów (lub o wersję instrumentalną) albo pokierować generowaniem tekstów w wybranym przez siebie kierunku.

Tekst piosenki będzie w języku, w którym napiszesz prompta. Możesz też poprosić o tekst w innym języku, np. „Napisz tekst w języku francuskim”.

Używanie własnych tekstów

Aby podać modelowi własny tekst, dodaj go do promptu z prefiksem „Lyrics:” (Tekst):

Lyrics:

[Intro]
Oooh, oooh

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

[Chorus]
...

Możesz dodać do fragmentów utworu tytuły sekcji, takie jak [Intro], [Verse 1], [Pre-chorus], [Chorus] i [Outro].

Jeśli chcesz, aby słowo lub wiersz się powtarzał, np. jako echo lub w wykonaniu chórzystów, możesz umieścić go w nawiasach: „Let's go (go)”.

Promptowanie modelu do pisania tekstów

Jeśli chcesz, aby Lyria 3.5 napisała dla Ciebie tekst, najlepiej podaj w prompcie szczegóły dotyczące tego, o czym ma być tekst. W przeciwnym razie model będzie musiał wywnioskować temat na podstawie promptu dotyczącego muzyki, a wynik może nie być zgodny z Twoimi oczekiwaniami.

Tekst opowiada o utraconej miłości i bólu złamanego serca. Piosenkarka wspomina dawny związek i zalewają ją wspomnienia.

Jeśli chcesz, aby refren się powtarzał, poproś o to w prompcie:

Tekst opowiada o utraconej miłości i bólu złamanego serca. Piosenkarka wspomina dawny związek i zalewają ją wspomnienia. Potężny refren skupia się na przezwyciężeniu bólu i ruszeniu dalej.

Lyria 3.5 automatycznie dostosuje strukturę tekstu do rodzaju muzyki, o którą prosisz, ale możesz też ponownie podkreślić to w prompcie. Na przykład:

Utwór EDM, w którym w kółko powtarza się to samo energiczne wyrażenie.

Możesz też poprosić o efekty wokalne, które nie są ściśle związane z tekstem, np.:

W całym utworze powtarza się fragment filmu z dialogiem „Nie wierzę!”.
Energetyczny utwór techno. Tuż przed dropem dźwięk nagle się urywa i cichy głos mówi: „Nie wiem, co tu robię”, a potem następuje drop.
Utwór rozpoczyna się rozmową o tym, że filmy z lat 90. były lepsze niż te, które powstają obecnie. Następnie utwór przechodzi w piosenkę popową.

Wokale

Możesz określić, w jaki sposób chcesz otrzymać tekst. Aby uzyskać najlepsze wyniki, podaj szczegółowy profil wokalisty, uwzględniając płeć, barwę i zakres głosu.

Sopran żeński: czysta, krystaliczna barwa głosu o zwinnej, wznoszącej się jakości. Potrafi osiągać wysokie tony o powietrznej, zwiewnej fakturze.
Alt żeński: bogaty, ciepły i chrapliwy niższy zakres. Głos o dymnym brzmieniu z elementami fry, pełen emocji i rezonansu.
Tenor męski: jasny, przenikliwy i energetyczny. Młodzieńczy tembr z lekkim nosowym zabarwieniem, przebijający się przez miks dzięki wysokiej mocy beltingu.
Męski baryton: głęboki, czekoladowy i aksamitnie gładki. Głos z głębi klatki piersiowej, kojący i miękki.
Weathered Rocker (Male): chropowaty i szorstki głos o grubym brzmieniu, przypominający grunge z lat 90. Napięty górny zakres intensywności emocjonalnej.

Inne parametry promptu

Możesz też uwzględnić te parametry, aby jeszcze bardziej doprecyzować prompt:

BPM: ustaw tempo (np. „120 BPM”, „wolne tempo około 70 BPM”).
Tonacja/skala: określ tonację (np. „w tonacji G-dur”, „d-moll”).
Nastrój i atmosfera: używaj przymiotników opisowych (np. „nostalgiczny”, „agresywny”, „etericzny”, „marzycielski”).
Czas trwania: model klipu zawsze tworzy 30-sekundowe klipy. W przypadku modelu Pro określ w prompcie żądaną długość (np. „utwórz 2-minutową piosenkę”) lub użyj sygnatur czasowych, aby kontrolować czas trwania.

Przykładowe prompty

Oto kilka przykładów skutecznych promptów:

"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."

Sprawdzone metody

Najpierw przetestuj klip. Użyj szybszego modelu lyria-3-clip-preview, aby eksperymentować z promptami, zanim zdecydujesz się na wygenerowanie pełnej wersji za pomocą modelu lyria-3.5.
Unikaj ogólników. Niejasne prompty dają ogólne wyniki. Aby uzyskać najlepszy rezultat, podaj instrumenty, tempo, tonację, nastrój i strukturę.
Dopasuj język. Prompt w języku, w którym chcesz uzyskać tekst piosenki.
Używaj tagów sekcji. Tagi [Verse], [Chorus] i [Bridge] nadają modelowi wyraźną strukturę, której może się trzymać.
Oddziel słowa piosenki od instrukcji. Podając niestandardowy tekst, wyraźnie oddziel go od instrukcji dotyczących kierunku muzycznego.

Ograniczenia

Bezpieczeństwo: wszystkie prompty są sprawdzane przez filtry bezpieczeństwa. Prompty, które aktywują filtry, zostaną zablokowane. Obejmuje to prompty, które wymagają konkretnych głosów artystów lub generowania tekstów piosenek chronionych prawem autorskim.
Znaki wodne: wszystkie wygenerowane pliki audio zawierają znak wodny audio SynthID, który umożliwia identyfikację. Ten znak wodny jest niesłyszalny dla ludzkiego ucha i nie wpływa na wrażenia słuchowe.
Edycja wieloetapowa: generowanie muzyki to proces jednoetapowy. W obecnej wersji Lyrii 3.5 nie jest obsługiwane iteracyjne edytowanie ani ulepszanie wygenerowanego klipu za pomocą wielu promptów.
Długość: model Clip zawsze generuje 30-sekundowe klipy. Model Pro generuje utwory trwające kilka minut. Na dokładny czas trwania może wpływać prompt.
Determinacja: wyniki mogą się różnić w zależności od połączenia, nawet w przypadku tego samego prompta.

Co dalej?

Sprawdź ceny modeli Lyria 3.5.
Wypróbuj generowanie muzyki w czasie rzeczywistym za pomocą Lyrii RealTime.
Generowanie rozmów z udziałem wielu osób za pomocą modeli TTS.
Dowiedz się, jak generować obrazy i filmy.
Dowiedz się, jak Gemini może rozumieć pliki audio.
Prowadź rozmowę w czasie rzeczywistym z Gemini za pomocą interfejsu Live API.