Lyria 3 Pro API 実装ガイド — テキスト・画像からプロ品質のフルレングス楽曲を生成する

pip install google-genai

from google import genai
from google.genai import types
 
# クライアントの作成
client = genai.Client(api_key="YOUR_GEMINI_API_KEY")

from google import genai
from google.genai import types
 
client = genai.Client(api_key="YOUR_GEMINI_API_KEY")
 
# テキストプロンプトからフルレングス楽曲を生成
response = client.models.generate_content(
    model="lyria-3-pro-preview",
    contents="穏やかなアコースティックギターのメロディから始まり、"
             "徐々にストリングスが加わって壮大に盛り上がる"
             "映画のエンドロールのような3分間の楽曲。"
             "テンポは BPM 80、キーは C メジャー。",
    config=types.GenerateContentConfig(
        response_modalities=["AUDIO", "TEXT"],
    ),
)
 
# レスポンスの解析
for part in response.parts:
    if part.text is not None:
        # 生成された歌詞や楽曲構造の説明
        print("楽曲情報:", part.text)
    elif part.inline_data is not None:
        # オーディオデータの保存（MP3形式）
        with open("generated_track.mp3", "wb") as f:
            f.write(part.inline_data.data)
        print(f"楽曲を保存しました: generated_track.mp3")
        print(f"MIME タイプ: {part.inline_data.mime_type}")

import pathlib
from google import genai
from google.genai import types
 
client = genai.Client(api_key="YOUR_GEMINI_API_KEY")
 
# 画像ファイルの読み込み
image_path = pathlib.Path("sunset_beach.jpg")
image_data = image_path.read_bytes()
 
# 画像 + テキストで楽曲を生成
response = client.models.generate_content(
    model="lyria-3-pro-preview",
    contents=[
        types.Part.from_bytes(
            data=image_data,
            mime_type="image/jpeg",
        ),
        "この写真の雰囲気に合うリラックスした "
        "チルアウトミュージックを生成してください。"
        "アンビエントシンセとアコースティックギターを中心に。",
    ],
    config=types.GenerateContentConfig(
        response_modalities=["AUDIO", "TEXT"],
    ),
)
 
# オーディオの保存
for part in response.parts:
    if part.inline_data is not None:
        with open("image_inspired_track.mp3", "wb") as f:
            f.write(part.inline_data.data)
        print("画像インスパイア楽曲を保存しました")

response = client.models.generate_content(
    model="lyria-3-pro-preview",
    contents=[
        types.Part.from_uri(
            file_uri="https://example.com/mountain_sunrise.jpg",
            mime_type="image/jpeg",
        ),
        "この風景にふさわしいオーケストラ楽曲を生成",
    ],
    config=types.GenerateContentConfig(
        response_modalities=["AUDIO", "TEXT"],
    ),
)

from google import genai
from google.genai import types
 
client = genai.Client(api_key="YOUR_GEMINI_API_KEY")
 
# Interactions API でセッションを作成
interaction = client.interactions.create(
    model="lyria-3-pro-preview",
    config=types.InteractionConfig(
        response_modalities=["AUDIO", "TEXT"],
    ),
)
 
# 第1ターン：楽曲の方向性を指示
response1 = interaction.send_message(
    "エレクトロニカとジャズを融合した"
    "チルホップトラックを作りたい。"
    "BPM 90、ローファイな質感で。"
)
 
# 生成結果を確認
for part in response1.parts:
    if part.text:
        print("初回生成の情報:", part.text)
    elif part.inline_data:
        with open("draft_v1.mp3", "wb") as f:
            f.write(part.inline_data.data)
 
# 第2ターン：フィードバックに基づくリファインメント
response2 = interaction.send_message(
    "いい感じですが、もう少しサックスのソロパートを"
    "中盤に追加して、終盤はピアノで静かに締めてください。"
)
 
for part in response2.parts:
    if part.inline_data:
        with open("draft_v2.mp3", "wb") as f:
            f.write(part.inline_data.data)
        print("リファイン版を保存しました")

import asyncio
from google import genai
from google.genai import types
 
async def generate_track_async(prompt: str, output_path: str):
    """非同期で楽曲を生成し、ファイルに保存する"""
    client = genai.Client(api_key="YOUR_GEMINI_API_KEY")
 
    response = await client.aio.models.generate_content(
        model="lyria-3-pro-preview",
        contents=prompt,
        config=types.GenerateContentConfig(
            response_modalities=["AUDIO", "TEXT"],
        ),
    )
 
    for part in response.parts:
        if part.inline_data is not None:
            with open(output_path, "wb") as f:
                f.write(part.inline_data.data)
            return output_path
 
    return None
 
async def batch_generate():
    """複数トラックを並行生成する"""
    tasks = [
        generate_track_async(
            "明るく元気なポップソング、BPM 120",
            "track_pop.mp3"
        ),
        generate_track_async(
            "ダークなアンビエントシンセウェーブ、BPM 85",
            "track_ambient.mp3"
        ),
        generate_track_async(
            "ジャジーなピアノトリオ、BPM 110",
            "track_jazz.mp3"
        ),
    ]
 
    results = await asyncio.gather(*tasks)
    for path in results:
        if path:
            print(f"生成完了: {path}")
 
# 実行
asyncio.run(batch_generate())

structured_prompt = """
ジャンル: シネマティック・オーケストラ
テンポ: BPM 72
キー: D マイナー
ムード: 壮大で感動的、希望に満ちた
 
楽曲構造:
- イントロ (0:00-0:20): ソロチェロのメロディ、静寂の中に響く
- 第1ヴァース (0:20-0:50): ストリングスカルテットが加わり、主題を提示
- ビルドアップ (0:50-1:20): ホルンとティンパニが加わり、徐々にダイナミクスを上げる
- クライマックス (1:20-2:00): フルオーケストラの壮大なサウンド、メインテーマの変奏
- アウトロ (2:00-2:40): ピアノとストリングスで静かに、余韻を残して終わる
 
参考アーティスト: Hans Zimmer, Joe Hisaishi
SynthID ウォーターマーク: 有効
"""
 
response = client.models.generate_content(
    model="lyria-3-pro-preview",
    contents=structured_prompt,
    config=types.GenerateContentConfig(
        response_modalities=["AUDIO", "TEXT"],
    ),
)

import time
from google import genai
from google.genai import types
 
class MusicGenerationService:
    """本番向け音楽生成サービス"""
 
    def __init__(self, api_key: str):
        self.client = genai.Client(api_key=api_key)
        self.max_retries = 3
        self.retry_delay = 2  # 秒
 
    def generate_with_retry(
        self,
        prompt: str,
        output_path: str,
        model: str = "lyria-3-pro-preview",
    ) -> dict:
        """リトライ付きの楽曲生成"""
        last_error = None
 
        for attempt in range(self.max_retries):
            try:
                response = self.client.models.generate_content(
                    model=model,
                    contents=prompt,
                    config=types.GenerateContentConfig(
                        response_modalities=["AUDIO", "TEXT"],
                    ),
                )
 
                result = {"text": None, "audio_path": None}
 
                for part in response.parts:
                    if part.text is not None:
                        result["text"] = part.text
                    elif part.inline_data is not None:
                        with open(output_path, "wb") as f:
                            f.write(part.inline_data.data)
                        result["audio_path"] = output_path
 
                if result["audio_path"]:
                    return result
 
                # オーディオが返されなかった場合
                raise ValueError(
                    "レスポンスにオーディオデータが含まれていません"
                )
 
            except Exception as e:
                last_error = e
                print(
                    f"試行 {attempt + 1}/{self.max_retries} 失敗: {e}"
                )
                if attempt < self.max_retries - 1:
                    wait = self.retry_delay * (2 ** attempt)
                    print(f"{wait}秒後にリトライします...")
                    time.sleep(wait)
 
        # 全リトライ失敗時は Clip モデルにフォールバック
        if model == "lyria-3-pro-preview":
            print("Pro モデル失敗 → Clip モデルにフォールバック")
            return self.generate_with_retry(
                prompt, output_path,
                model="lyria-3-clip-preview"
            )
 
        raise RuntimeError(
            f"楽曲生成に失敗しました（{self.max_retries}回リトライ後）: "
            f"{last_error}"
        )
 
    def generate_with_validation(
        self,
        prompt: str,
        output_path: str,
        min_size_bytes: int = 50000,
    ) -> dict:
        """バリデーション付きの楽曲生成"""
        result = self.generate_with_retry(prompt, output_path)
 
        if result["audio_path"]:
            import os
            file_size = os.path.getsize(result["audio_path"])
            if file_size < min_size_bytes:
                raise ValueError(
                    f"生成されたファイルが小さすぎます "
                    f"({file_size} bytes < {min_size_bytes} bytes)"
                )
            result["file_size"] = file_size
 
        return result
 
# 使用例
service = MusicGenerationService(api_key="YOUR_GEMINI_API_KEY")
result = service.generate_with_validation(
    prompt="ジャズピアノトリオ、BPM 120、スウィング感のある演奏",
    output_path="output/jazz_trio.mp3",
    min_size_bytes=100000,
)
print(f"生成完了: {result}")

def select_model(use_case: dict) -> str:
    """ユースケースに応じてモデルを選択する"""
    if use_case.get("duration_needed", 0) <= 30:
        return "lyria-3-clip-preview"
 
    if use_case.get("needs_structure", False):
        return "lyria-3-pro-preview"
 
    if use_case.get("realtime", False):
        return "lyria-realtime-exp"
 
    if use_case.get("high_volume", False):
        # 大量生成はコスト効率の良い Clip を推奨
        return "lyria-3-clip-preview"
 
    return "lyria-3-pro-preview"
 
# 使用例
model = select_model({
    "duration_needed": 180,  # 3分
    "needs_structure": True,
    "high_volume": False,
})
print(f"推奨モデル: {model}")
# 出力: 推奨モデル: lyria-3-pro-preview

# ストックミュージック一括生成の例
genres = [
    {"genre": "Corporate", "prompt": "明るく前向きなコーポレートBGM、BPM 110"},
    {"genre": "Cinematic", "prompt": "映画のトレーラー向け壮大なオーケストラ、BPM 90"},
    {"genre": "Lo-Fi", "prompt": "リラックスしたLo-Fiビート、BPM 80、雨の音入り"},
    {"genre": "Electronic", "prompt": "テクノロジー系動画向けエレクトロニカ、BPM 128"},
]
 
for item in genres:
    result = service.generate_with_validation(
        prompt=item["prompt"],
        output_path=f"stock/{item['genre'].lower()}_001.mp3",
    )
    print(f"{item['genre']}: {result['audio_path']}")