PoradnikiMuzyka

Uzupełnianie muzyki

Edytuj i łącz sekcje istniejących utworów

Uzupełnianie muzyki za pomocą modelu music_v2 lub music_v2_5 pozwala modyfikować konkretne fragmenty utworu, zachowując resztę bez zmian. Zapisz wygenerowany utwór, a następnie odwołaj się do jego części w planie kompozycji, aby je zachować, wygenerować ponownie lub na ich podstawie tworzyć nowe audio.

Jak to działa

Plan kompozycji music_v2 lub music_v2_5 to uporządkowana lista chunków. Każdy chunk ma jeden z dwóch typów:

  • Chunk generowania — tworzy nowe audio na podstawie text i stylów. Użyj go, aby ponownie wygenerować sekcję lub dodać nowy materiał.
  • Chunk referencji audio — wstawia bez zmian fragment zapisanego utworu. Użyj go, aby zachować sekcję istniejącego utworu dokładnie taką, jaka jest.

Szybki start

1

Zapisz utwór do uzupełniania

Utwór do uzupełniania możesz zapisać na dwa sposoby: wygenerować nowy utwór z store_for_inpainting lub przesłać istniejący plik audio.

import os
from dotenv import load_dotenv
from elevenlabs.client import ElevenLabs
load_dotenv()
elevenlabs = ElevenLabs(api_key=os.environ.get("ELEVENLABS_API_KEY"))
# Generate a song and store it for later inpainting
response = elevenlabs.music.compose_detailed(
    prompt="An upbeat pop song with verse and chorus",
    music_length_ms=60000,
    model_id="music_v2_5",
    store_for_inpainting=True
)
song_id = response.song_id
# Save the audio
with open("original.mp3", "wb") as f:
    f.write(response.audio)
2

Zachowaj i wygeneruj ponownie chunky

Utwórz plan łączący chunky referencji audio (zachowane) z chunkami generowania (wygenerowane ponownie), a następnie przekaż go do compose z model_id="music_v2_5":

# Keep the first 30 seconds, regenerate the rest with a new style
composition_plan = {
    "chunks": [
        # Keep the original first 30 seconds unchanged
        {
            "song_id": song_id,
            "range": {"start_ms": 0, "end_ms": 30000}
        },
        # Regenerate the chorus with a new style
        {
            "text": "[Chorus]\nWe're rising up tonight\nNothing can stop us now",
            "duration_ms": 30000,
            "positive_styles": ["bigger drums", "layered vocals", "anthemic"],
            "negative_styles": ["sparse", "minimal"],
            "context_adherence": "high"
        }
    ]
}
audio = elevenlabs.music.compose(
    composition_plan=composition_plan,
    model_id="music_v2_5",
)
with open("edited.mp3", "wb") as f:
    for chunk in audio:
        f.write(chunk)

Warunkowanie

Chunk generowania można warunkować fragmentem zapisanego audio za pomocą conditioning_ref. Model generuje chunk ponownie, zachowując zbliżone cechy muzyczne referencji. Określ, jak ściśle chunk ma podążać za referencją, używając condition_strength (low, medium, high lub xhigh).

{
  "text": "[Chorus]\nThis is my moment\nI won't let it go",
  "duration_ms": 15000,
  "positive_styles": ["powerful vocals", "full band", "anthemic"],
  "negative_styles": [],
  "context_adherence": "high",
  "conditioning_ref": {
    "song_id": "vVtPM1Sas70E2LIhQFch",
    "range": { "start_ms": 30000, "end_ms": 45000 }
  },
  "condition_strength": "high"
}

Pierwszy chunk wpływa na generowanie wszystkich kolejnych chunków. Aby warunkować cały utwór na podstawie referencji, zastosuj conditioning_ref od pierwszego chunku.

Referencja warunkująca może trwać maksymalnie 30 sekund (30 000 ms).

Zgodność z kontekstem

Każdy chunk generowania ma poziom context_adherence, który określa, jak ściśle podąża za sąsiednimi chunkami:

  • high (domyślnie) — zachowuje spójność z otaczającymi chunkami. Użyj go, by uzyskać płynne przejścia między zachowanym a wygenerowanym ponownie audio.
  • medium — równoważy spójność i swobodę twórczą.
  • low — pozwala chunkowi odbiegać od kontekstu i być bardziej kreatywnym.

Przykłady

Edytuj jedną sekcję

Wygeneruj zwiastun filmowy, a potem wygeneruj ponownie tylko outro z innym tekstem.

1

Wygeneruj oryginał

composition_plan = {
    "chunks": [
        {
            "text": "[Intro]\nIn a world beyond code\nWhere sound becomes life",
            "duration_ms": 15000,
            "positive_styles": ["cinematic", "epic", "orchestral", "low strings", "suspenseful"],
            "negative_styles": ["acoustic", "pop", "minimalistic"],
            "context_adherence": "high"
        },
        {
            "text": "[Build]\nTechnology awakens the future\nShaping every word into power",
            "duration_ms": 20000,
            "positive_styles": ["rising brass", "full orchestra", "epic"],
            "negative_styles": ["acoustic", "pop"],
            "context_adherence": "high"
        },
        {
            "text": "[Bridge]\n(ah ah ah ah)",
            "duration_ms": 15000,
            "positive_styles": ["ethereal choir", "crescendo"],
            "negative_styles": [],
            "context_adherence": "high"
        },
        {
            "text": "[Outro]\nThe voice of tomorrow, unleashed\nElevenLabs",
            "duration_ms": 10000,
            "positive_styles": ["deep narration", "epic finale"],
            "negative_styles": [],
            "context_adherence": "high"
        }
    ]
}
response = elevenlabs.music.compose_detailed(
    composition_plan=composition_plan,
    model_id="music_v2_5",
    store_for_inpainting=True
)
song_id = response.song_id
2

Edytuj tylko outro

Zachowaj pierwsze trzy sekcje (sekundy 0–50) w jednym fragmencie referencyjnym audio i wygeneruj ponownie outro:

edited_plan = {
    "chunks": [
        # Keep the intro, build, and bridge unchanged
        {
            "song_id": song_id,
            "range": {"start_ms": 0, "end_ms": 50000}
        },
        # Regenerate the outro with new lyrics
        {
            "text": "[Outro]\nThe future has arrived\nElevenLabs",
            "duration_ms": 10000,
            "positive_styles": ["deep narration", "epic finale"],
            "negative_styles": [],
            "context_adherence": "high"
        }
    ]
}
audio = elevenlabs.music.compose(composition_plan=edited_plan, model_id="music_v2_5")

Rozszerz utwór

Dodaj nowe intro i outro do istniejącego utworu.

1

Wygeneruj oryginał

response = elevenlabs.music.compose_detailed(
    prompt="Berlin night club techno",
    music_length_ms=60000,
    model_id="music_v2_5",
    store_for_inpainting=True
)
song_id = response.song_id
2

Rozszerz o nowe intro i outro

Umieść zachowany fragment oryginału między dwoma nowymi fragmentami generowania:

extend_plan = {
    "chunks": [
        # New intro
        {
            "text": "[Intro]",
            "duration_ms": 30000,
            "positive_styles": ["techno", "building tension", "filtered synths"],
            "negative_styles": [],
            "context_adherence": "high"
        },
        # Keep the core of the original (seconds 10-50)
        {
            "song_id": song_id,
            "range": {"start_ms": 10000, "end_ms": 50000}
        },
        # New outro
        {
            "text": "[Outro]",
            "duration_ms": 30000,
            "positive_styles": ["techno", "fading out", "sparse"],
            "negative_styles": [],
            "context_adherence": "high"
        }
    ]
}
audio = elevenlabs.music.compose(composition_plan=extend_plan, model_id="music_v2_5")

Utwórz płynną pętlę

Wygeneruj frazę muzyczną i utwórz pętlę za pomocą fragmentu „spajającego”, który łączy ten sam fragment powtórzony dwa razy.

1

Wygeneruj krótki klip

composition_plan = {
    "chunks": [
        {
            "text": "[Solo Acoustic]",
            "duration_ms": 10000,
            "positive_styles": ["acoustic guitar", "fingerpicking", "warm tone", "soft dynamics"],
            "negative_styles": ["electric", "drums", "electronic"],
            "context_adherence": "high"
        }
    ]
}
response = elevenlabs.music.compose_detailed(
    composition_plan=composition_plan,
    model_id="music_v2_5",
    store_for_inpainting=True
)
song_id = response.song_id
2

Utwórz pętlę z fragmentem spajającym

loop_plan = {
    "chunks": [
        # Loop start - keep a slice of the original
        {
            "song_id": song_id,
            "range": {"start_ms": 3000, "end_ms": 8000}
        },
        # Glue - generate a smooth transition between the two slices
        {
            "text": "[Glue]",
            "duration_ms": 3000,
            "positive_styles": ["acoustic guitar", "fingerpicking", "smooth transition"],
            "negative_styles": [],
            "context_adherence": "high"
        },
        # Loop end - keep the same slice again
        {
            "song_id": song_id,
            "range": {"start_ms": 3000, "end_ms": 8000}
        }
    ]
}
audio = elevenlabs.music.compose(composition_plan=loop_plan, model_id="music_v2_5")

Wygeneruj podobny utwór

Oprzyj zupełnie nowy utwór na krótkim fragmencie istniejącego, aby zachować jego cechy muzyczne. Ponieważ pierwszy fragment wpływa na wszystkie kolejne, zastosowanie conditioning_ref do pierwszego fragmentu kształtuje całe generowanie, choć tylko ten fragment odnosi się do zapisanego audio.

1

Wygeneruj oryginał

response = elevenlabs.music.compose_detailed(
    prompt="An upbeat pop song with bright synths and driving drums",
    music_length_ms=60000,
    model_id="music_v2_5",
    store_for_inpainting=True
)
song_id = response.song_id
2

Wygeneruj nowy utwór oparty na oryginale

similar_plan = {
    "chunks": [
        # The first chunk conditions the whole song on the reference
        {
            "text": "[Verse]\nSalt on my skin from a borrowed sea\nCounting the heartbeats it takes to break free",
            "duration_ms": 30000,
            "positive_styles": ["pop", "energetic", "bright synths", "driving drums"],
            "negative_styles": ["sparse", "minimal"],
            "context_adherence": "high",
            "conditioning_ref": {
                "song_id": song_id,
                "range": {"start_ms": 0, "end_ms": 10000}
            },
            "condition_strength": "high"
        },
        {
            "text": "[Chorus]\nWe're rising up tonight\nNothing can stop us now",
            "duration_ms": 30000,
            "positive_styles": ["bigger drums", "layered vocals", "anthemic"],
            "negative_styles": ["sparse", "minimal"],
            "context_adherence": "high"
        }
    ]
}
audio = elevenlabs.music.compose(composition_plan=similar_plan, model_id="music_v2_5")

Informacje o fragmentach

Plan music_v2 zawiera do 30 fragmentów. Każdy fragment jest fragmentem generowania albo referencyjnym fragmentem audio.

Fragment generowania

PoleTypOpis
textstringNazwa sekcji w nawiasach kwadratowych ([Verse 1]), wersy tekstu i wbudowane wskazówki w nawiasach klamrowych ({scratching}).
duration_msnumberDługość w milisekundach (3 000–120 000).
positive_stylesarrayStyle i wskazówki do uwzględnienia (maks. 50).
negative_stylesarrayStyle i wskazówki, których należy unikać (maks. 50). Domyślnie pusta.
context_adherencestringlow, medium lub high (domyślnie). Określa, jak ściśle fragment podąża za otaczającymi go fragmentami.
conditioning_refobject | nullOpcjonalny fragment { song_id, range } zapisanego audio, na którym opiera się generowanie. Domyślnie null.
condition_strengthstring | nulllow, medium (domyślnie), high lub xhigh. Określa, jak ściśle fragment podąża za referencją warunkującą.

Style pierwszego fragmentu są najważniejsze, bo określają ogólny ton i gatunek. Staraj się używać co najmniej 6–7 stylów we wczesnych fragmentach, dopóki kierunek nie będzie ustalony.

Referencyjny fragment audio

PoleTypOpis
song_idstringID zapisanego utworu, z którego pochodzi audio.
rangeobjectFragment { start_ms, end_ms } zapisanego utworu do wstawienia bez zmian.

Ograniczenia

OgraniczenieWartość
Maksymalna liczba fragmentów w planie30
Minimalny czas trwania fragmentu3 sekundy (3 000 ms)
Maksymalny czas trwania fragmentu2 minuty (120 000 ms)
Maksymalna referencja warunkująca30 sekund (30 000 ms)
Minimalny zakres czasu50 ms

Kolejne kroki

Plany kompozycji

Poznaj podstawy planów kompozycji

Dokumentacja API

Pełna dokumentacja API