Música sem Segredos - Musica para todos

Como gerar músicas com o modelo open source YuE2-3B no Google Colab

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

Por Que The Entertainer Não Envelhece? A Matemática por Trás do Clássico de Scott Joplin

Você já parou para pensar por que algumas melodias, mesmo tendo mais de um século de idade, recusam-se a envelhecer? Se você ligar o rádio, assistir a um filme antigo, ou até mesmo ouvir a música de fundo em um parque de diversões, é provável que seja atingido por aquela famosa introdução no piano: “Ta-da-ta, ta-ta-ta… Ta-da-ta, ta-ta-ta”. Imediatamente, seu cérebro reconhece a melodia, seu pé começa a bater no chão no compasso da música e um sorriso involuntário surge. Essa obra, que se infiltrou no DNA cultural do mundo todo, chama-se “The Entertainer“.

Mas o que faz dessa peça, composta em 1902 pelo norte-americano Scott Joplin, um sucesso tão estrondoso e duradouro?

Imagine a música como uma engrenagem mecânica complexa, como o interior de um relógio suíço antigo. Por fora, vemos apenas os ponteiros se movendo com leveza e precisão (a melodia cativante). Por dentro, no entanto, há uma série de molas de tensão, rodas dentadas e contrapesos trabalhando de forma milimétrica. Durante muito tempo, muitas pessoas — inclusive músicos de formação acadêmica — consideraram o ragtime apenas como uma “música de salão” alegre e descompromissada. No entanto, quando você coloca uma lupa sobre as partituras de Scott Joplin, descobre que a sua música é, na verdade, uma verdadeira aula de composição clássica, contraponto, síncope e forma.

Neste post, vamos mergulhar fundo na história, na estrutura teórica e nos segredos de “The Entertainer”. Vamos entender a genialidade de Scott Joplin, o “Rei do Ragtime”, e como ele construiu essa ponte entre a música afro-americana e a tradição erudita europeia. E, para coroar nossa jornada, vou disponibilizar no final um guia completo e estruturado de arranjos dessa obra-prima para duos que todo mundo ama: Violino e Violão, Clarinete e Violão, e Bandolim e Violão.

Prepare seu instrumento, afine seus ouvidos e vamos juntos decifrar esse mistério musical.

O Que é o Ragtime? A Fusão de Dois Mundos

Para entender “The Entertainer”, precisamos primeiro entender o terreno onde ela nasceu: o ragtime.

A virada do século XX nos Estados Unidos testemunhou uma profunda transformação cultural. A sociedade deixava de ser majoritariamente agrária para se tornar intensamente urbana. No epicentro dessa metamorfose, surgiu um gênero instrumental de piano chamado ragtime. O nome vem da expressão em inglês “ragged time”, que pode ser traduzida livremente como “tempo rasgado” ou “tempo esfarrapado”. Mas não se engane com o nome: não há nada de bagunçado nessa música.

Pense no ragtime como um coquetel musical perfeito. De um lado, temos a rigidez estrutural da música clássica europeia, especificamente o formato das marchas de compositores como John Philip Sousa. Do outro lado, temos a vitalidade rítmica e a síncope das tradições afro-americanas, herdadas dos cantos de trabalho e das danças dos escravizados libertos.

A síncope é o coração do ragtime. Mas o que é, teoricamente, uma síncope? De acordo com os principais teóricos (e se você já estudou pelo livro de Teoria da Música do Bohumil Med, vai se lembrar disso), a síncope ocorre quando há um deslocamento do acento métrico natural do compasso. Em um compasso quaternário comum (4/4), os tempos forte e meio-forte caem no primeiro e no terceiro tempo. A síncope acontece quando prolongamos uma nota de um tempo fraco (ou parte fraca de um tempo) para um tempo forte (ou parte forte). Isso cria uma sensação de “puxão” ou de antecipação rítmica. A melodia parece estar sempre um passo à frente da batida principal, “dançando” sobre os compassos.

Essa tensão constante entre a melodia sincopada (tocada pela mão direita no piano) e o acompanhamento de marcha rigorosamente no tempo (tocado pela mão esquerda) é o que dá ao ragtime o seu “balanço” inconfundível.

Scott Joplin: O Arquiteto e o Rei do Ragtime

Scott Joplin não queria apenas fazer as pessoas dançarem; ele queria fazer as pessoas ouvirem e respeitarem a sua música.

Nascido entre 1867 e 1868 no nordeste do Texas, filho de uma família de trabalhadores ferroviários e ex-escravizados, Joplin demonstrou talento musical desde cedo. Sua educação formal começou quando um professor de música alemão, Julius Weiss, percebeu o talento do garoto e passou a lhe dar aulas gratuitas de piano, teoria musical e música clássica europeia. Essa base erudita foi fundamental.

Enquanto a maioria dos pianistas de bares e bordéis tocava ragtime de forma improvisada, muitas vezes acelerando o andamento para animar o público, Joplin fazia questão de anotar cada nota meticulosamente em uma partitura. Ele enxergava o ragtime não como um entretenimento passageiro, mas como a legítima música erudita norte-americana, digna de ser executada nas maiores salas de concerto do mundo, como se fosse uma sonata de Beethoven ou um noturno de Chopin.

Joplin era tão obcecado pelo rigor técnico que, em muitas de suas partituras, ele escrevia um aviso no topo da página: “It is never right to play ragtime fast” (Nunca é correto tocar ragtime rápido). Ele sabia que, se o andamento fosse muito rápido, a clareza da síncope e a complexidade harmônica se perderiam em uma confusão sonora. O ragtime precisava de “respiro”, de um andamento moderado para que a sua mágica matemática funcionasse.

Apesar de ter composto 44 peças originais de ragtime, um balé e duas óperas (incluindo a ambiciosa Treemonisha), foi com “The Maple Leaf Rag” (1899) e “The Entertainer” (1902) que ele garantiu seu lugar no panteão dos gigantes da música.

A Anatomia de “The Entertainer”: Uma Aula de Estrutura

Vamos colocar “The Entertainer” na nossa mesa de dissecação musical. Por que ela é tão brilhante?

A peça é estruturada na clássica forma de marcha do ragtime, que geralmente segue um padrão seccional. A estrutura de “The Entertainer” é: Introdução – A – A – B – B – A – C – C – D – D.

Cada letra representa uma seção distinta de 16 compassos. Essa repetição e contraste mantêm o ouvinte engajado, trazendo melodias familiares de volta e introduzindo novas ideias harmônicas logo em seguida.

A Introdução e o Tema “A”

A obra começa com uma introdução marcante de quatro compassos. Ela não é apenas uma “chamada” para a música; é uma progressão de semicolcheias que desce da região aguda do piano e aterrissa de forma triunfante na tonalidade principal da música: Dó Maior (C).

Logo em seguida, entra o Tema A, que é a melodia que todos conhecemos. Aqui, vamos pensar nos intervalos. Durante muito tempo, a melodia salta utilizando intervalos de terça e de sexta. Por exemplo, a famosa frase rítmica usa o salto de terças e sextas menores e maiores que se resolvem perfeitamente dentro da escala de Dó Maior. A genialidade de Joplin está no uso dos cromatismos (notas que não pertencem à escala original de Dó Maior, como o Ré sustenido ou Fá sustenido), que funcionam como “notas de passagem” ou apoios para criar um colorido voltado para o jazz que estava nascendo.

A Engrenagem da Mão Esquerda (O Padrão Stride)

Enquanto a mão direita salta sincopadamente, o que a mão esquerda está fazendo? Está fazendo o papel do bumbo e dos pratos de uma banda marcial.

A mão esquerda toca o famoso padrão Oom-Pah ou baixo alternado (stride). No primeiro tempo do compasso (o tempo forte), a mão esquerda toca uma nota grave (a tônica ou a quinta do acorde). No segundo tempo, ela salta para a região central do piano e toca o acorde completo. No terceiro tempo, toca o baixo novamente; no quarto, o acorde.

Essa base rítmica de marcha funciona como um pêndulo de relógio, um metrônomo humano que nunca vacila. É justamente essa estabilidade da mão esquerda que permite que a “malandragem” rítmica da mão direita brilhe. Sem uma fundação sólida, a síncope não tem sentido, pois a síncope só existe porque nosso cérebro está esperando o tempo forte que a mão esquerda marca!

A Modulação para a Subdominante (Seção C)

No ragtime, é quase uma regra de ouro que o “Trio” (a terceira grande seção da música, ou Seção C) module para uma nova tonalidade para renovar o interesse auditivo do público. Em “The Entertainer”, após retornarmos ao Tema A, a música modula para Fá Maior (F), que é a tonalidade da Subdominante de Dó Maior.

Nessa Seção C, a dinâmica muda. Como os teóricos costumam indicar, o ragtime usa muita dinâmica de “pergunta e resposta”. Uma frase pode começar de forma suave (piano) e ser respondida com energia e vivacidade (forte). Ao ler a partitura original de Joplin, notamos que esses detalhes de dinâmica são essenciais. Se tocarmos tudo no mesmo volume do início ao fim, a música perde sua tridimensionalidade e soa como o toque de uma caixa de música robotizada.

O Renascimento: A Ressurreição da Partitura Esquecida

É triste pensar que, após a morte de Scott Joplin em 1917, o ragtime perdeu força, sendo rapidamente substituído pelo Jazz e pelo Swing. A música de Joplin ficou acumulando poeira por décadas, conhecida apenas por um pequeno nicho de historiadores musicais.

A história só mudou na década de 1970, mais de meio século depois. Primeiro, o pianista com formação erudita Joshua Rifkin lançou um álbum chamado Scott Joplin: Piano Rags (1970) pela Nonesuch Records. Rifkin fez algo revolucionário: ele tocou o ragtime exatamente como estava escrito, sem firulas de improvisação de bar, com um andamento lento e acadêmico. O álbum foi um sucesso esmagador.

Pouco depois, o diretor de cinema George Roy Hill estava preparando o filme The Sting (conhecido no Brasil como Golpe de Mestre), lançado em 1973 e estrelado por Paul Newman e Robert Redford. Hill ouviu as gravações de Rifkin e decidiu que a música de Joplin, mesmo sendo de 1902 (e o filme se passando nos anos 1930), tinha o tom irônico, elegante e espirituoso perfeito para o filme.

O compositor Marvin Hamlisch foi contratado para adaptar as partituras de Joplin para uma pequena orquestra e para o piano solo, criando a trilha sonora. O resultado? “The Entertainer” alcançou o número 3 da parada da Billboard em 1974 e Marvin Hamlisch ganhou um Oscar pela trilha sonora. A obra de Joplin finalmente teve a consagração global que ele tanto sonhou em vida.

Como Ler e Adaptar Partituras para o Violão

Antes de entrarmos nos arranjos para duos, precisamos falar sobre a base harmônica da maioria desses grupos: o violão. Como já mencionei em outros posts sobre “Como ler partitura para violão“, quem escreve arranjos ou vai ler uma partitura de violão precisa estar atento a certas particularidades.

Ler partitura de violão pode parecer desafiador. A leitura das notas é feita na clave de sol, mas com um detalhe crucial: o violão é um instrumento transpositor de oitava. O som que escutamos no violão soa exatamente uma oitava abaixo do que está escrito na partitura. O Dó central do piano (Dó 3), que fica na primeira linha suplementar inferior da clave de sol, equivale ao Dó tocado na 5ª corda (casa 3) do violão.

Em nossos arranjos de ragtime, o papel do violão é imitar a mão esquerda do piano. Isso significa que o violonista terá a árdua (porém deliciosa) tarefa de fazer o padrão de marcha de baixos alternados. O polegar da mão direita (p) fará o “bumbo” tocando os baixos nos tempos 1 e 3, enquanto os dedos indicador, médio e anelar (i, m, a) tocarão os acordes nos tempos 2 e 4 imitando o som da “caixa clara” ou o acorde da mão esquerda do piano.

Adaptando a Obra-Prima: Arranjos de “The Entertainer” para Duos

Tocar “The Entertainer” no piano solo é um grande desafio técnico. Mas o que acontece quando queremos dividir essa responsabilidade entre dois instrumentistas?

Nos arranjos para duos de câmara, separamos as funções: o instrumento melódico (Violino, Clarinete ou Bandolim) assume o papel brilhante e sincopado da mão direita do piano, enquanto o Violão assume toda a estrutura de base, o groove e a harmonia da mão esquerda.

Para que a execução seja confortável nos instrumentos de corda e de sopro, muitas vezes transpomos a obra da tonalidade original (Dó Maior) para Sol Maior (G) ou Ré Maior (D). Nessas tonalidades, o violão possui cordas soltas (os bordões Mi, Lá e Ré) que facilitam a execução dos baixos alternados em andamentos mais vivos.

Adaptando a Obra-Prima: A Liberdade dos Arranjos para Violino, Clarinete e Bandolim

Você já reparou como uma mesma roupa pode ter um caimento completamente diferente dependendo de quem a veste? Na música, o princípio é exatamente o mesmo. Quando tiramos “The Entertainer” de sua “roupa” original — o piano solo pensado por Scott Joplin — e a vestimos em novas formações, como os duos de cordas ou sopros, não precisamos (e nem devemos) ficar engessados à partitura original.

A beleza de um arranjo não está em tentar imitar o piano nota por nota, mas sim em traduzir a intenção e o balanço do ragtime utilizando os “superpoderes” e as particularidades de cada instrumento. Concessões precisam ser feitas, e são justamente essas alterações criativas que tornam o seu arranjo diferente, único e vivo.

Ao se fazer um duo entre um instrumento solo e o violão, este assume o trabalho pesado da fundação, imitando a mão esquerda do piano com baixos precisos e acordes curtos. Mas o grande “pulo do gato” está no tratamento da melodia. Cada instrumento que fará o solo possui suas particularidades que podem e devem ser exploradas.

Arranjando para violão e violino

Veja o vídeo a seguir com um arranjo para violão e violino. Neste caso, o arranjador optou por usar o pizzicato na introdução como forma de diferenciação. A introdução não entra de forma tradicional com o arco longo. O arranjo explora o pizzicato — técnica em que o violinista belisca as cordas com os dedos, criando um som curto, percussivo e bem-humorado. Esse começo quase “malandro” fisga o ouvinte imediatamente, preparando o terreno para a entrada do arco nas síncopes brilhantes do Tema A. O violino não é um piano, e usar o pizzicato é uma forma inteligente de brincar com o ritmo.

Arranjando para Bandolim

E se passarmos essa mesma melodia para o bandolim? O bandolim compartilha a mesma afinação do violino, mas possui uma anatomia diferente: ele tem cordas duplas, ou seja, duas cordas de metal afinadas na mesma nota soando juntas a cada ataque da palheta. Isso lhe confere um timbre estalado e ressonante que nos remete imediatamente à malemolência do choro brasileiro. Porém, o som da corda beliscada morre rápido. Como resolver as notas longas que Joplin escreveu no piano? O arranjador aqui lança mão do trêmolo — um movimento extremamente rápido e contínuo da palheta para cima e para baixo. O trêmolo cria a ilusão de uma nota mágica, sustentada e expressiva, compensando a falta de sustentação natural do instrumento e dando um tempero emocional fortíssimo ao ragtime.

Arranjando para clarinete

Por fim, quando entregamos a síncope ao fôlego quente de um clarinete, o jogo muda de novo. O clarinete não tem cordas para beliscar, mas tem uma agilidade mecânica e um timbre amadeirado perfeitos para a exploração do trinado (a alternância veloz entre a nota principal e sua vizinha superior). Inserir trinados no final das frases ou na nota de resolução da síncope confere à melodia aquele sotaque atrevido das bandas de Dixieland de Nova Orleans. O clarinete permite “brincar” com a nota, arrastando-a com glissandos sutis que o piano, com suas teclas de afinação fixa, jamais conseguiria fazer.

Adquira estes e outros arranjos: Clique Aqui

O Legado que Superou o Tempo

Adaptar “The Entertainer” para violino, bandolim ou clarinete acompanhados pelo violão é a prova definitiva de que a música bem construída é como uma argila de altíssima qualidade: ela aceita ser moldada.

A trajetória dessa melodia é, em si, um roteiro de cinema. Nascida da mente brilhante de um músico afro-americano marginalizado, que buscava provar o valor acadêmico de sua arte, a peça quase se perdeu nas sombras do tempo. Décadas depois, ressurgiu gloriosa, arrebatando o mundo e até mesmo prêmios Oscar nos anos 1970.

Tocar “The Entertainer” — seja com um beliscão de pizzicato, com a vibração intensa de um trêmolo ou com o sorriso de um trinado — é reverenciar a história da música. Scott Joplin nos deixou a arquitetura; a decoração, agora, é por nossa conta. Ele inseriu o ragtime no cânone da música para nunca mais sair, mostrando-nos que a boa matemática harmônica não tem prazo de validade.

Referências

The Entertainer (rag) – Wikipedia

The Entertainer: piano sheet music

Edição Inglês por Scott Joplin (Autor) Formato: Capa comum

Marvin Hamlisch / Scott Joplin – The Sting (Original Motion Picture Soundtrack) – Vinyl (LP, Stereo, Reissue), 1974 [r5469214] | Discogs

Scott Joplin – The Entertainer, Songs & Compositions

Scott Joplin – SHSMO Historic Missourians

Scott Joplin | History | Research Starters | EBSCO Research