De quem é a música que você criou com inteligência artificial? A pergunta parece simples, mas a resposta pode mudar conforme o plano que você paga, a versão dos termos de uso e até o mês em que você aceitou as regras.
Imagine a cena. Você passa uma tarde ajustando uma letra, escolhe o estilo, gera dez versões e, finalmente, uma delas emociona. Você baixa o arquivo, manda para um amigo e talvez use como trilha de um vídeo da sua escola de música. Seis meses depois, cancela a assinatura porque o orçamento apertou. O que acontece com aquela música? Você ainda pode usá-la? Pode monetizar? E quem decide isso?
Neste post eu mostro uma alternativa: gerar músicas com um modelo de código aberto, o YuE2-3B, rodando no Google Colab. Vamos conversar primeiro sobre direitos autorais e termos de uso, depois sobre o hardware necessário e, por fim, seguir o passo a passo com os códigos prontos para copiar e colar. Open source, ou código aberto, quer dizer que os arquivos do modelo e o código para usá-lo estão publicados e qualquer pessoa pode baixá-los e executá-los por conta própria, respeitando a licença.
Antes da primeira nota: o que você assina quando usa uma plataforma
Plataformas como o Suno são práticas: você escreve uma ideia, clica em um botão e minutos depois tem uma música completa. Só que essa praticidade vem com um contrato, e vale ler as cláusulas com a mesma atenção que daríamos ao contrato de uma gravadora.
Em 2026, depois do acordo com a Warner Music Group, o Suno reescreveu partes dos seus termos. A linguagem que antes dizia que o assinante era dono das músicas passou a dizer que ele pode receber direitos de uso comercial. A própria empresa explica que, mesmo com esses direitos, o usuário em geral não é considerado o proprietário da obra, porque o resultado foi gerado pela plataforma. Os termos também deixam claro que não há garantia de que algum direito autoral venha a existir sobre o que foi gerado.
Há outros pontos. Músicas criadas no plano gratuito servem apenas para uso não comercial e não podem ser monetizadas. Direitos retroativos podem ser concedidos em casos limitados, mas sem garantia. Novos termos entraram em vigor em 3 de setembro de 2026 e trouxeram limites de download: 7 downloads no total para o plano gratuito, 20 por mês no Pro e 60 por mês no Premier, valendo inclusive para músicas criadas antes da mudança. E, segundo análises dos termos, o usuário concede à plataforma uma licença ampla para usar o que envia e o que é gerado para melhorar os modelos dela.
A empresa informa que, ao cancelar, a biblioteca continua na sua conta e que as músicas baixadas como assinante mantêm os direitos comerciais. Então o problema não é necessariamente o que está escrito hoje. O problema é quem escreve as regras. Elas mudaram mais de uma vez em poucos meses, podem mudar de novo, e você, que depende da plataforma para acessar e baixar o seu material, não tem poder de negociação nenhum. É como compor num estúdio que pode alterar o contrato depois da gravação. Por isso, confira sempre os termos vigentes: eles podem ter mudado desde que escrevi este texto.
O que muda com um modelo de código aberto
Quando você roda um modelo aberto, a lógica se inverte. Você baixa os arquivos do modelo, executa na máquina que alugou e o resultado é um arquivo de áudio que está nas suas mãos. Não existe conta de assinante, não existe limite de downloads e não existe uma cláusula de plataforma de música dizendo o que você pode ou não fazer com o resultado. Se o site de um serviço fechar amanhã, o modelo que você baixou continua funcionando. É a diferença entre assinar um serviço de streaming e ter o seu próprio equipamento de gravação.
Mas atenção a um ponto que muita gente esquece: controle não é o mesmo que liberdade total. O modelo tem a sua própria licença. Os pesos do YuE2-3B (os “pesos” são os números aprendidos pelo modelo, ou seja, o conhecimento dele guardado em arquivo) são publicados sob a licença Creative Commons CC BY-NC 4.0, que permite uso não comercial e exige atribuição aos autores. O código de inferência que usamos para rodar o modelo é Apache 2.0, bem mais permissivo, mas são os pesos que definem o que você pode fazer com a música.
Na prática, isso é ótimo para estudo, ensino, demos, protótipos de arranjo, trilhas para projetos pessoais e experimentos. Se a intenção é vender ou monetizar, leia a licença na página oficial do modelo e, se possível, consulte um advogado especializado em direitos autorais. Eu não sou advogado e este texto não é aconselhamento jurídico.
Existe ainda a questão da autoria. Em geral, a proteção por direito autoral está ligada à criação humana, inclusive na legislação brasileira. Quanto mais da sua contribuição houver na obra, como a letra escrita por você, a estrutura, as escolhas de arranjo e, depois, a edição e a mixagem, mais sólida tende a ser a sua posição. Use a IA como um músico de estúdio, e não como substituta do compositor.
E os dados usados no treinamento?
Há uma pergunta que ainda não tem resposta definitiva: as músicas usadas para treinar esses modelos. Diversas disputas judiciais ao redor do mundo discutem se treinar uma IA com obras protegidas é uso permitido, e acordos como o do Suno com a Warner mostram que o mercado está negociando as regras enquanto o jogo acontece. Isso vale para plataformas fechadas e para modelos abertos, e é um ponto da legislação que pode mudar nos próximos anos. Por isso, acompanhe as notícias e guarde o registro de qual modelo e qual configuração você usou em cada faixa. O script que vamos usar salva os “artefatos” de cada geração, o que ajuda nisso.
No balanço geral, ainda me parece melhor gerar a música com um modelo aberto, sob o seu controle: você sabe qual licença se aplica, escolhe a versão, guarda os seus arquivos e não depende de uma empresa manter as regras de hoje. É uma decisão de risco, e não uma garantia, e cada pessoa deve pesar a sua situação.
O obstáculo: a placa de vídeo
Modelos de geração de música fazem bilhões de cálculos ao mesmo tempo, e quem executa esse trabalho pesado é a GPU, a placa de vídeo. Pense na CPU do computador como um excelente maestro que lê a partitura nota por nota, enquanto a GPU é uma orquestra inteira tocando em paralelo. Para rodar o YuE2-3B na qualidade original, sem compressão, a recomendação é uma placa com cerca de 24 GB de memória de vídeo (a VRAM), que é onde o modelo precisa caber enquanto trabalha. Existem versões quantizadas, isto é, compactadas com alguma perda de qualidade, que rodam em placas menores, mas a experiência fica mais limitada.
Placas com essa quantidade de memória custam muitos milhares de reais, e no Brasil os impostos e o câmbio empurram o preço ainda mais para cima. Para um músico ou professor que só quer experimentar, comprar uma placa dessas é como comprar um piano de cauda para descobrir se gosta de tocar. A saída é alugar o “estúdio” por hora.
Google Colab: o estúdio de ensaio alugado por hora
O Google Colab (abreviação de Colaboratory) é um serviço do Google que permite escrever e executar código Python direto no navegador, em computadores da própria empresa, incluindo máquinas com GPU. Funciona como alugar uma sala de ensaio: você paga pelo tempo em que usa e, quando termina, devolve a sala.
O modelo de cobrança mais interessante para o nosso caso é o pay as you go, ou “pague pelo que usar”. Em vez de assinar um plano mensal, você compra compute units, as unidades de computação, que são a moeda do Colab. Na última consulta que fiz, o preço era de US$ 9,99 por 100 unidades, sem assinatura, e as unidades expiram 90 dias depois da compra, ou seja, três meses. Uma GPU A100 consome algo entre 10 e 15 unidades por hora, o que dá de 7 a 10 horas de uso a cada 100 unidades, ou algo em torno de US$ 1 a US$ 1,50 por hora. Os valores são em dólar, mudam com o tempo e podem variar por região, então confira a página de preços do Colab antes de comprar.
Como cada música leva alguns minutos para ser gerada, 100 unidades rendem dezenas de gerações por uma fração do preço de uma placa de vídeo. Há dois cuidados. O primeiro é que o Google não garante qual GPU você vai receber. O segundo é que as unidades continuam sendo gastas enquanto a sessão estiver aberta, mesmo que você não esteja gerando nada. Terminou? Encerre a sessão em Ambiente de execução > Desconectar e excluir ambiente de execução.
O Colab é Linux: como ativar a placa de vídeo
Por baixo da interface, o Colab roda o Linux (Ubuntu). Isso explica alguns detalhes dos códigos: os comandos que começam com ponto de exclamação (!) são enviados ao terminal do Linux, como o apt-get, que instala programas. Já os que começam com %%writefile gravam o conteúdo da célula em um arquivo. Uma célula é cada bloco de código do notebook, e você executa uma de cada vez clicando no botão de play ao lado dela.
Antes de qualquer coisa, ative a placa de vídeo. A sugerida para este modelo é a A100, que tem memória de sobra para ele:
- Acesse colab.research.google.com e crie um novo notebook.
- No menu, abra Ambiente de execução > Alterar tipo de ambiente de execução.
- Em Acelerador de hardware, escolha a GPU A100.
- Salve e clique em Conectar.
Se a A100 não estiver disponível no momento, o Colab pode oferecer outra placa. Nesse caso, tente novamente mais tarde. O nosso script confere a GPU logo no início e avisa se nenhuma for encontrada.
Como funcionam os códigos em Python
Todos os códigos deste post estão em Python, uma linguagem muito usada em inteligência artificial e conhecida por ser legível, quase como ler uma receita. Você não precisa saber programar para usá-los: basta copiar, colar e alterar alguns textos, como o estilo e a letra.
O fluxo é sempre o mesmo e lembra o trabalho em estúdio. Primeiro carregamos o modelo na placa de vídeo, como ligar os equipamentos. Depois definimos o estilo, que é o briefing para a banda (gênero, instrumentos, clima), e a letra, que traz também a estrutura da música, com marcações como [Verse] e [Chorus]. Em seguida mandamos gerar e, por fim, salvamos o áudio e os artefatos, que são os arquivos auxiliares do processo, incluindo o plano de melodia e acordes.
Dois parâmetros merecem explicação. O primeiro é o cot=”full”. A sigla vem de chain of thought, “cadeia de raciocínio”. Em vez de gerar o áudio de uma só vez, o modelo antes escreve um plano simbólico da música, com melodia e acordes em notação ABC (um formato de texto simples para escrever partituras) e só depois transforma esse plano em som. É como um arranjador que rascunha a partitura antes de chamar os músicos. Para covers, o modo recomendado é o cot=”melody”. O segundo parâmetro é a seed, ou semente: o número que inicia o sorteio interno do modelo. Com a mesma semente e os mesmos textos, você tende a obter o mesmo resultado, como repetir o mesmo take. Trocando a semente, nascem novas variações.
E por que usamos um venv? O YuE2 pede o Python 3.10, enquanto o Colab costuma vir com outra versão. A solução é criar um ambiente virtual, ou venv: uma pasta com o seu próprio Python e as suas próprias bibliotecas, isolada do resto do sistema. Pense numa cabine de gravação com isolamento acústico, em que o que acontece lá dentro não interfere no estúdio ao lado. Por isso os scripts são executados com /content/yue2_env/bin/python e não com o Python padrão.
Passo 1: criar o ambiente com Python 3.10
Na primeira célula instalamos o Python 3.10 com o apt-get, o gerenciador de programas do Ubuntu, e criamos o ambiente virtual na pasta /content/yue2_env. A execução leva alguns minutos.
Célula 1
# Célula 1: Instalar o Python 3.10 e criar o ambiente virtual (venv)
!sudo apt-get update -y
!sudo apt-get install -y python3.10 python3.10-dev python3.10-venv
!python3.10 -m venv /content/yue2_env
Passo 2: instalar o YuE2
A segunda célula atualiza o pip (o instalador de pacotes do Python), instala uma versão específica da biblioteca huggingface-hub, baixa o pacote de inferência do YuE2 direto do repositório oficial na Hugging Face e o instala dentro do venv. A Hugging Face é uma espécie de “GitHub dos modelos de IA”, onde ficam publicados os arquivos do modelo. Os pesos, que ocupam alguns gigabytes, normalmente são baixados na primeira vez que o script carrega o modelo, então a primeira execução é a mais demorada.
Célula 2
# Célula 2: Instalar o pacote de inferência no ambiente criado
!/content/yue2_env/bin/python -m pip install –upgrade pip
!/content/yue2_env/bin/python -m pip install huggingface-hub==0.36.2
!/content/yue2_env/bin/hf download m-a-p/YuE2-3B yue2_infer-0.1.5-py3-none-any.whl –local-dir .
!/content/yue2_env/bin/python -m pip install ./yue2_infer-0.1.5-py3-none-any.whl
Passo 3: um teste rápido com o exemplo oficial
Antes de personalizar, vale confirmar que tudo funciona usando o exemplo de demonstração do próprio repositório. O script abaixo baixa um pedido pronto (estilo, letra e seed) e gera a música. Se tudo correr bem, você terá o arquivo song.flac (o FLAC é um formato de áudio sem perda de qualidade) ao lado do notebook.
Célula 4
# Célula 3: Criar o arquivo de teste com o exemplo oficial
%%writefile teste_demo.py
import json
from pathlib import Path
from huggingface_hub import hf_hub_download
from yue2 import YuE2Pipeline
print(“Carregando o YuE2Pipeline na GPU…”)
pipe = YuE2Pipeline.from_pretrained(“m-a-p/YuE2-3B”, device=”cuda”)
# Baixar o exemplo de demonstração do repositório
repo = “m-a-p/YuE2-3B”
prompt_path = hf_hub_download(repo, “examples/tonight-awake.json”)
demo = json.loads(Path(prompt_path).read_text(encoding=”utf-8″))
style, lyrics = demo[“style”], demo[“lyrics”]
print(“Gerando a música…”)
song = pipe(style=style, lyrics=lyrics, cot=”full”, seed=demo[“seed”])
# Salvar a música e os artefatos
song.save(“song.flac”)
song.save_artifacts(“outputs/song”)
print(“Geração concluída! Arquivo salvo como ‘song.flac’.”)
# Célula 4: Executar o teste no Python 3.10 do venv
!/content/yue2_env/bin/python teste_demo.py
Passo 4: o script de geração configurável
Este é o script para o uso no dia a dia. Todas as opções ficam no bloco CONFIGURE AQUI, no começo do arquivo, então você só mexe nessa parte. Veja o que cada uma faz:
- CAPTION: o estilo da música, com gênero, instrumentos e clima. Escreva em inglês, como nos exemplos oficiais.
- LYRICS: a letra, com marcações como [Verse 1] e [Chorus]. Escreva [Instrumental] para uma faixa sem voz.
- VOCAL_LANGUAGE: o idioma do vocal. Use “pt” para português.
- DURATION: o modelo decide o tamanho da faixa, então este valor apenas corta o áudio, com um fade-out de 1,5 segundo, caso ele passe do limite. Use -1 para não cortar.
- BPM e KEYSCALE: andamento e tonalidade. Entram como texto no estilo, funcionando como um pedido e não como uma ordem rígida.
- BATCH_SIZE: quantas variações gerar em sequência.
- AUDIO_FORMAT: o formato final do arquivo (wav, flac, mp3, opus, aac), convertido com o ffmpeg.
- SEED: com -1, a semente é sorteada a cada geração. Com um número fixo, o resultado tende a se repetir.
- OUTPUT_DIR: a pasta onde os arquivos serão salvos.
Célula 5
# Célula 5: Criar o script de geração configurável
%%writefile /content/gerar_Musica.py
import os, sys, subprocess, inspect, time, random
from pathlib import Path
# — 0. Garantir que roda dentro do ambiente virtual do YuE2 —
VENV_DIR = “/content/yue2_env”
VENV_PYTHON = f”{VENV_DIR}/bin/python”
if os.path.exists(VENV_PYTHON) and os.path.realpath(sys.prefix) != os.path.realpath(VENV_DIR):
os.execv(VENV_PYTHON, [VENV_PYTHON] + sys.argv)
try:
import torch
except ImportError:
torch = None
# ===================== CONFIGURE AQUI =====================
CAPTION = “blues with piano, cello, double bass, sax and soft drums”
LYRICS = “””[Verse 1]
Caminhando pela rua hoje
Pensando nas palavras que você me disse
Tudo parece diferente agora
Mas eu vou encontrar meu caminho
[Chorus]
Eu sigo em frente, eu sigo forte
Esse é o meu lugar
“”” # ou escreva a letra; “[Instrumental]” = sem vocal
VOCAL_LANGUAGE = “pt” # “en”, “pt”, “es”, “ja”… ou “unknown” (automático)
DURATION = 30 # segundos: corta a faixa nesse tamanho (com fade-out); -1 = não corta
BPM = 85 # None = automático
KEYSCALE = “A Major” # ex.: “C Major”; “” = automático
BATCH_SIZE = 1 # quantas variações gerar
AUDIO_FORMAT = “wav” # flac, mp3, opus, aac, wav, wav32
SEED = -1 # -1 = aleatória
USE_LM = True # True = planejamento completo de melodia e acordes (cot=”full”)
PROJECT_ROOT = “/content/YuE2” # só usado se existir: entra no sys.path
OUTPUT_DIR = “/content/musicas_geradas”
CONFIG_OVERRIDE = None # ex.: “m-a-p/YuE2-3B” (modelo principal)
LM_OVERRIDE = None # modelo de planejamento separado, se a pipeline aceitar
# ==========================================================
DEFAULT_MODEL = “m-a-p/YuE2-3B”
def run(cmd):
subprocess.run(cmd, shell=True, check=True)
# — 1. GPU —
if torch is not None:
if not torch.cuda.is_available():
sys.exit(“Nenhuma GPU encontrada. No Colab: Ambiente de execução > Alterar tipo > GPU.”)
props = torch.cuda.get_device_properties(0)
print(f”GPU: {props.name} | VRAM: {props.total_memory / 1024**3:.1f} GB”)
else:
info = subprocess.run(“nvidia-smi –query-gpu=name,memory.total –format=csv,noheader”,
shell=True, capture_output=True, text=True).stdout.strip()
if not info:
sys.exit(“Nenhuma GPU encontrada. No Colab: Ambiente de execução > Alterar tipo > GPU.”)
print(f”GPU: {info}”)
model_id = CONFIG_OVERRIDE or DEFAULT_MODEL
print(f”Python: {sys.executable}”)
print(f”Modelo: {model_id} | planejamento (cot): {‘ligado’ if USE_LM else ‘desligado’}”)
# — 2. Importar o YuE2 (instalado no venv) —
if os.path.isdir(PROJECT_ROOT):
sys.path.insert(0, PROJECT_ROOT)
try:
from yue2 import YuE2Pipeline
except ImportError:
sys.exit(“O módulo ‘yue2’ não foi encontrado. Rode antes as células 1 e 2 “
“(criar o venv /content/yue2_env e instalar o yue2_infer) e tente de novo.”)
Path(OUTPUT_DIR).mkdir(parents=True, exist_ok=True)
# — 3. Carregar o modelo na GPU —
print(“Carregando o YuE2Pipeline na GPU…”)
load_kwargs = {“device”: “cuda”}
if LM_OVERRIDE:
if “lm_model” in inspect.signature(YuE2Pipeline.from_pretrained).parameters:
load_kwargs[“lm_model”] = LM_OVERRIDE
else:
print(“Aviso: from_pretrained não aceita ‘lm_model’; LM_OVERRIDE ignorado.”)
pipe = YuE2Pipeline.from_pretrained(model_id, **load_kwargs)
# — 4. Montar estilo e letra —
instrumental = LYRICS.strip().lower() in (“[instrumental]”, “”)
style_parts = [CAPTION.strip()]
if instrumental:
style_parts += [“Instrumental”, “no vocals”]
if BPM:
style_parts.append(f”{BPM} bpm”)
if KEYSCALE:
style_parts.append(f”{KEYSCALE} key”)
if VOCAL_LANGUAGE and VOCAL_LANGUAGE.lower() != “unknown” and not instrumental:
style_parts.append(f”{VOCAL_LANGUAGE} vocals”)
style = “. “.join(style_parts)
lyrics = (“[Intro – instrumental]\n\n[verse – instrumental, no vocals]\n\n”
“[chorus – instrumental, no vocals]\n\n[outro – instrumental, final chord resolution]\n”
if instrumental else LYRICS)
print(f”Estilo final: {style}”)
# — 5. Pós-processamento (formato e duração) com ffmpeg —
CODECS = { # formato: (extensão, argumentos do ffmpeg)
“wav”: (“wav”, “-c:a pcm_s16le”),
“wav32”: (“wav”, “-c:a pcm_f32le”),
“flac”: (“flac”, “-c:a flac”),
“mp3”: (“mp3”, “-c:a libmp3lame -q:a 2”),
“opus”: (“opus”, “-c:a libopus -b:a 128k”),
“aac”: (“aac”, “-c:a aac -b:a 192k”),
}
fmt = AUDIO_FORMAT.lower()
if fmt not in CODECS:
sys.exit(f”AUDIO_FORMAT inválido: {AUDIO_FORMAT}. Use: {‘, ‘.join(CODECS)}”)
ext, codec_args = CODECS[fmt]
def audio_length(path):
out = subprocess.run(
f’ffprobe -v error -show_entries format=duration -of csv=p=0 “{path}”‘,
shell=True, capture_output=True, text=True).stdout.strip()
return float(out) if out else None
def convert(src, dst, max_seconds=None):
“””Converte para o formato pedido e, se passar da duração, corta com fade-out.”””
cut = “”
length = audio_length(src)
if max_seconds and length and length > max_seconds + 0.5:
fade_start = max(max_seconds – 1.5, 0)
cut = f’-t {max_seconds} -af “afade=t=out:st={fade_start}:d=1.5″‘
run(f’ffmpeg -y -loglevel error -i “{src}” {cut} {codec_args} “{dst}”‘)
# — 6. Gerar (uma variação por iteração) —
stamp = time.strftime(“%Y%m%d_%H%M%S”)
saved = []
for i in range(BATCH_SIZE):
seed = random.randint(0, 2**31 – 1) if SEED == -1 else SEED + i
name = f”musica_{stamp}_v{i + 1}_seed{seed}”
print(f”\nGerando variação {i + 1}/{BATCH_SIZE} (seed {seed})…”)
t0 = time.time()
gen_kwargs = dict(style=style, lyrics=lyrics, seed=seed)
if USE_LM:
gen_kwargs[“cot”] = “full” # planejamento completo de melodia e acordes
song = pipe(**gen_kwargs)
raw = os.path.join(OUTPUT_DIR, f”{name}_raw.flac”)
song.save(raw)
song.save_artifacts(os.path.join(OUTPUT_DIR, f”{name}_artefatos”))
final = os.path.join(OUTPUT_DIR, f”{name}.{ext}”)
convert(raw, final, max_seconds=DURATION if DURATION and DURATION > 0 else None)
if os.path.abspath(raw) != os.path.abspath(final):
os.remove(raw)
saved.append(final)
print(f”Variação {i + 1} pronta em {time.time() – t0:.1f}s”)
if torch is not None:
torch.cuda.empty_cache()
# — 7. Resumo —
print(“\nGeração concluída! Arquivos de áudio:”)
for f in saved:
print(” “, f)
print(f”Artefatos (por variação) em: {OUTPUT_DIR}/*_artefatos”)
O restante do script cuida do trabalho de bastidor: confere se a GPU está ativa, garante que está rodando dentro do venv, monta o texto de estilo (acrescentando BPM, tonalidade e idioma), carrega o modelo, gera cada variação, converte o áudio e imprime um resumo com o caminho dos arquivos. Cada variação também ganha uma pasta de artefatos com o plano de melodia e acordes.
Passo 5: gerar e ouvir
Execute a célula abaixo. A primeira execução baixa o modelo e pode demorar, e as seguintes são mais rápidas. Acompanhe a mensagem “Gerando variação 1/1” e aguarde alguns minutos.
Célula 6
# Célula 6: Executar a geração
!/content/yue2_env/bin/python /content/gerar_Musica.py
Quando terminar, a célula a seguir toca as últimas músicas geradas ali mesmo no notebook, sem precisar baixar nada.
Célula 7
# Célula 7: Para ouvir as últimas músicas geradas
import glob, os
from IPython.display import Audio, display
exts = (“.wav”, “.flac”, “.mp3”, “.opus”, “.aac”)
files = [f for f in glob.glob(“/content/musicas_geradas/*”) if f.lower().endswith(exts)]
for f in sorted(files, key=os.path.getmtime)[-4:]:
print(f)
display(Audio(f))
Se aparecer a mensagem de que nenhuma GPU foi encontrada, volte ao menu de Ambiente de execução e confirme o acelerador escolhido. Se o aviso disser que o módulo yue2 não foi encontrado, execute novamente as células 1 e 2, pois o ambiente virtual desaparece quando a sessão é reiniciada. E lembre-se: cada geração gasta unidades de computação, então teste primeiro com BATCH_SIZE = 1 e DURATION curta, e só depois gere em maior quantidade.
Como escrever o estilo e a letra
O código é só metade do trabalho. A outra metade é escrever bons pedidos. Alguns princípios que funcionam bem:
- Estilo curto e específico: gênero, instrumentos, clima e andamento. Por exemplo: “blues with piano, cello, double bass, sax and soft drums”.
- Estrutura clara: use seções como [Intro], [Verse], [Chorus] e [Outro], com linhas curtas e uma ideia por linha, pensando em como seriam cantadas.
- Instrumental: com LYRICS = “[Instrumental]”, o script já acrescenta “no vocals” ao estilo e monta a estrutura sozinho.
- Variações: gere várias versões com sementes diferentes e escolha a melhor, como quem escolhe entre takes.
Para controlar a dinâmica de uma faixa instrumental, você pode descrever o que acontece dentro de cada seção. Experimente colar o bloco abaixo no lugar de CAPTION, LYRICS e VOCAL_LANGUAGE do script. A mudança do idioma para “unknown” evita que o script acrescente “pt vocals” ao estilo de uma música que não tem voz.
CAPTION = “Orchestral instrumental in cinematic movie style, complete orchestra, strictly instrumental, clear production”
LYRICS = “””[Intro – instrumental]
[instrumental – verse 1]
dynamics increasing until climax, starting with woodwind until full orchestra, strictly instrumental, no vocals
[instrumental – chorus]
strings, brass and timpani, with energy, strictly instrumental, no vocals
[instrumental – verse 2]
dynamics decreasing in volume, cello solo, strictly instrumental, no vocals
[instrumental – ending]
full orchestra, strictly instrumental, no vocals
“””
VOCAL_LANGUAGE = “unknown”
Guarde suas músicas antes de encerrar a sessão
Tudo o que está na pasta /content some quando a sessão termina. Antes de desconectar, baixe os arquivos pelo painel de arquivos (o ícone de pasta na lateral esquerda; clique nos três pontinhos ao lado do arquivo e escolha Fazer download). Outra opção é montar o Google Drive com a célula abaixo, executada antes da geração, e apontar o OUTPUT_DIR para uma pasta dentro de /content/drive/MyDrive/. O Drive vai pedir autorização da sua conta Google.
# Opcional: monta o Google Drive para guardar as músicas (tire o # das duas linhas)
#from google.colab import drive
#drive.mount(‘/content/drive’)
Conclusão
Gerar música com um modelo aberto exige um pouco mais de trabalho do que clicar num botão, mas devolve algo valioso: clareza sobre as regras do jogo. Você sabe qual licença se aplica, onde estão os seus arquivos e quanto está pagando por hora de estúdio. Lembre-se apenas de que os pesos do YuE2-3B são de uso não comercial e de que a discussão sobre os dados de treinamento segue em aberto.
O YuE2 ainda permite fazer covers a partir de uma melodia em ABC, aplicar adaptadores LoRA para músicas instrumentais e rodar tudo em uma interface gráfica no ComfyUI. Esses são assuntos para os próximos posts. E você, o que pretende criar primeiro: uma canção com letra própria ou uma trilha instrumental? Conte nos comentários.
Para saber mais
- Página oficial do modelo YuE2-3B na Hugging Face
- The Science of AI Music: A Beginner’s Guide to AI Songwriting, Production & Music Creation (English Edition)
- AI Music Prompts: EDM: 1000+ Copy-Paste Prompts for Suno, Udio & AI Music Generators: 4
- Suno: atualização da política de downloads e dos Termos de Serviço
- Google Colab: planos e preços
- Google Colab