{/* Trang này được tạo tự động từ SKILL.md của kỹ năng bởi website/scripts/generate-skill-docs.py. Chỉnh sửa nguồn SKILL.md, không phải trang này. */}

Tạo âm thanh Audiocraft

AudioCraft: Chuyển văn bản thành âm nhạc MusicGen, chuyển văn bản thành âm thanh AudioGen.

Siêu dữ liệu kỹ năng

Nguồn	Đi kèm (được cài đặt theo mặc định)
Đường dẫn

skills/mlops/models/audiocraft ` | | Phiên bản |

1.0.0 ` | | Tác giả | Nghiên cứu dàn nhạc | | Giấy phép | MIT | | Phụ thuộc |

audiocraft

, `torch>=2.0.0

, transformers>=4.30.0 | | Nền tảng | Linux, macOS | | Thẻ |

Multimodal

, `Audio Generation

, `Text-to-Music

, `Text-to-Audio

, MusicGen |

Tham khảo: đầy đủ SKILL.md

thông tin

Sau đây là định nghĩa kỹ năng đầy đủ mà Hermes tải khi kỹ năng này được kích hoạt. Đây là những gì tác nhân coi là hướng dẫn khi kỹ năng được kích hoạt.

AudioCraft: Tạo âm thanh

Hướng dẫn toàn diện về cách sử dụng AudioCraft của Meta để tạo văn bản thành nhạc và chuyển văn bản thành âm thanh với MusicGen, AudioGen và EnCodec.

Khi nào nên sử dụng AudioCraft`Sử dụng AudioCraft khi:

• Cần tạo nhạc từ mô tả văn bản
• Tạo hiệu ứng âm thanh và âm thanh môi trường
• Xây dựng ứng dụng tạo nhạc
• Cần sáng tác nhạc theo giai điệu
• Muốn đầu ra âm thanh nổi
• Yêu cầu tạo nhạc có thể điều khiển được bằng cách chuyển kiểu`Các tính năng chính:
• MusicGen: Tạo văn bản thành nhạc với điều hòa giai điệu
• AudioGen: Tạo hiệu ứng chuyển văn bản thành âm thanh
• EnCodec: Bộ giải mã âm thanh thần kinh có độ trung thực cao
• Nhiều kích cỡ model: Nhỏ (300M) đến Lớn (3,3B)
• Hỗ trợ âm thanh nổi: Tạo âm thanh nổi hoàn chỉnh
• Điều hòa phong cách: MusicGen-Style dành cho thế hệ dựa trên tham chiếu`Sử dụng các lựa chọn thay thế thay thế:
• Âm thanh ổn định: Để tạo nhạc thương mại lâu hơn
• Bark: Để chuyển văn bản thành giọng nói với hiệu ứng âm nhạc/âm thanh
• Riffusion: Để tạo nhạc dựa trên quang phổ
• OpenAI Jukebox: Để tạo âm thanh thô với lời bài hát

Bắt đầu nhanh

Cài đặt

# From PyPI
pip install audiocraft

# From GitHub (latest)
pip install git+https://GitHub.com/facebookresearch/audiocraft.git

# Or use HuggingFace Transformers
pip install transformers torch torchaudio

`

### Chuyển văn bản thành nhạc cơ bản (AudioCraft)

``` python
 import torchaudio
from audiocraft.models import MusicGen

# Load model
model = MusicGen.get_pretrained('facebook/musicgen-small')

# Set generation parameters
model.set_generation_params(
    duration=8,  # seconds
    top_k=250,
    temperature=1.0
)

# Generate from text
descriptions = ["happy upbeat electronic dance music with synths"]
wav = model.generate(descriptions)

# Save audio
torchaudio.save("output.wav", wav[0].cpu(), sample_rate=32000)

`

### Sử dụng Transformers ôm mặt

`Python
from transformers import AutoProcessor, MusicgenForConditionalGeneration
 import scipy

# Load model and processor
processor = AutoProcessor.from_pretrained("facebook/musicgen-small")
model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small")
model.to("cuda")

# Generate music
inputs = processor(
    text=["80s pop track with bassy drums and synth"],
    padding=True,
    return_tensors="pt"
).to("cuda")

audio_values = model.generate(

    **inputs,
    do_sample=True,
    guidance_scale=3,
    max_new_tokens=256
)

# Save
sampling_rate = model.config.audio_encoder.sampling_rate
scipy.io.wavfile.write("output.wav", rate=sampling_rate, data=audio_values[0, 0].cpu().numpy())

`

### Chuyển văn bản thành âm thanh với AudioGen

``` python
from audiocraft.models import AudioGen

# Load AudioGen
model = AudioGen.get_pretrained('facebook/audiogen-medium')

model.set_generation_params(duration=5)

# Generate sound effects
descriptions = ["dog barking in a park with birds chirping"]
wav = model.generate(descriptions)

torchaudio.save("sound.wav", wav[0].cpu(), sample_rate=16000)

`

## Khái niệm cốt lõi

### Tổng quan về kiến trúc`<!-- ascii-guard-ignore -->

`

AudioCraft Architecture:
┌──────────────────────────────────────────────────────────────┐
│                    Text Encoder (T5)                          │
│                         │                                     │
│                    Text Embeddings                            │
└────────────────────────┬─────────────────────────────────────┘
                         │
┌────────────────────────▼─────────────────────────────────────┐
│              Transformer Decoder (LM)                         │
│     Auto-regressively generates audio tokens                  │
│     Using efficient token interleaving patterns               │
└────────────────────────┬─────────────────────────────────────┘
                         │
┌────────────────────────▼─────────────────────────────────────┐
│                EnCodec Audio Decoder                          │
│        Converts tokens back to audio waveform                 │
└──────────────────────────────────────────────────────────────┘

`

<!-- ascii-guard-ignore-end -->

### Các biến thể của mô hình

| Người mẫu | Kích thước | Mô tả | Trường hợp sử dụng |
|-------|------|-------------|----------|
| 
`musicgen-small
` | 300M | Chuyển văn bản thành nhạc | Thế hệ nhanh |
| 
`musicgen-medium
` | 1,5B | Chuyển văn bản thành nhạc | Cân bằng |
| 
`musicgen-large
` | 3,3B | Chuyển văn bản thành nhạc | Chất lượng tốt nhất |
| 
`musicgen-melody
` | 1,5B | Văn bản + giai điệu | Giai điệu điều hòa |
| 
`musicgen-melody-large
` | 3,3B | Văn bản + giai điệu | Giai điệu hay nhất |
| 
`musicgen-stereo-*
` | Khác nhau | Đầu ra âm thanh nổi | Thế hệ âm thanh nổi |
| 
`musicgen-style
` | 1,5B | Chuyển phong cách | Dựa trên tài liệu tham khảo |
| 
`audiogen-medium
` | 1,5B | Chuyển văn bản thành âm thanh | Hiệu ứng âm thanh |

### Tham số thế hệ

| Tham số | Mặc định | Mô tả |
|----------||----------|-------------|
| 
`duration
` | 8.0 | Độ dài tính bằng giây (1-120) |
| 
`top_k
` | 250 | Lấy mẫu Top-k |
| 
`top_p
` | 0,0 | Lấy mẫu hạt nhân (0 = bị vô hiệu hóa) |
| 
`temperature
` | 1.0 | Nhiệt độ lấy mẫu |
| 
`cfg_coef
` | 3.0 | Hướng dẫn không cần phân loại |

## Cách sử dụng MusicGen

### Tạo văn bản thành nhạc

`Python
from audiocraft.models import MusicGen
 import torchaudio`model = MusicGen.get_pretrained('facebook/musicgen-medium')

# Configure generation
model.set_generation_params(
    duration=30,          # Up to 30 seconds
    top_k=250,            # Sampling diversity
    top_p=0.0,            # 0 = use top_k only
    temperature=1.0,      # Creativity (higher = more varied)
    cfg_coef=3.0          # Text adherence (higher = stricter)
)

# Generate multiple samples
descriptions = [
    "epic orchestral soundtrack with strings and brass",
    "chill lo-fi hip hop beat with jazzy piano",
    "energetic rock song with electric guitar"
]

# Generate (returns [batch, channels, samples])
wav = model.generate(descriptions)

# Save each
for i, audio in enumerate(wav):
    torchaudio.save(f"music_\{i}.wav", audio.cpu(), sample_rate=32000)

`

### Thế hệ được điều hòa bởi giai điệu

`Python
from audiocraft.models import MusicGen
 import torchaudio

# Load melody model
model = MusicGen.get_pretrained('facebook/musicgen-melody')
model.set_generation_params(duration=30)

# Load melody audio
melody, sr = torchaudio.load("melody.wav")

# Generate with melody conditioning
descriptions = ["acoustic guitar folk song"]
wav = model.generate_with_chroma(descriptions, melody, sr)

torchaudio.save("melody_conditioned.wav", wav[0].cpu(), sample_rate=32000)

`

### Thế hệ âm thanh nổi

`Python
from audiocraft.models import MusicGen

# Load stereo model
model = MusicGen.get_pretrained('facebook/musicgen-stereo-medium')
model.set_generation_params(duration=15)

descriptions = ["ambient electronic music with wide stereo panning"]
wav = model.generate(descriptions)

# wav shape: [batch, 2, samples] for stereo
print(f"Stereo shape: \{wav.shape}")  # [1, 2, 480000]
torchaudio.save("stereo.wav", wav[0].cpu(), sample_rate=32000)

`

### Tiếp tục âm thanh

`Python
from transformers import AutoProcessor, MusicgenForConditionalGeneration`processor = AutoProcessor.from_pretrained("facebook/musicgen-medium")
model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-medium")

# Load audio to Continue
 import torchaudio
audio, sr = torchaudio.load("intro.wav")

# Process with text and audio
inputs = processor(
    audio=audio.squeeze().numpy(),
    sampling_rate=sr,
    text=["Continue with a epic chorus"],
    padding=True,
    return_tensors="pt"
)

# Generate continuation
audio_values = model.generate(**inputs, do_sample=True, guidance_scale=3, max_new_tokens=512)

`

## Cách sử dụng MusicGen-Style

### Thế hệ có phong cách

`Python
from audiocraft.models import MusicGen

# Load style model
model = MusicGen.get_pretrained('facebook/musicgen-style')

# Configure generation with style
model.set_generation_params(
    duration=30,
    cfg_coef=3.0,
    cfg_coef_beta=5.0  # Style influence
)

# Configure style conditioner
model.set_style_conditioner_params(
    eval_q=3,          # RVQ quantizers (1-6)
    excerpt_length=3.0  # Style excerpt length
)

# Load style reference
style_audio, sr = torchaudio.load("reference_style.wav")

# Generate with text + style
descriptions = ["upbeat dance track"]
wav = model.generate_with_style(descriptions, style_audio, sr)

`

### Tạo kiểu chỉ (không có văn bản)

`Python

# Generate matching style without text prompt
model.set_generation_params(
    duration=30,
    cfg_coef=3.0,
    cfg_coef_beta=None  # Disable double CFG for style-only
)

wav = model.generate_with_style([None], style_audio, sr)

`

## Cách sử dụng AudioGen

### Tạo hiệu ứng âm thanh

``` python
from audiocraft.models import AudioGen
 import torchaudio`model = AudioGen.get_pretrained('facebook/audiogen-medium')
model.set_generation_params(duration=10)

# Generate various sounds
descriptions = [
    "thunderstorm with heavy rain and lightning",
    "busy city traffic with car horns",
    "ocean waves crashing on rocks",
    "crackling campfire in forest"
]

wav = model.generate(descriptions)

for i, audio in enumerate(wav):
    torchaudio.save(f"sound_\{i}.wav", audio.cpu(), sample_rate=16000)

`

## Cách sử dụng EnCodec

### Nén âm thanh

`Python
from audiocraft.models import CompressionModel
 import torch
 import torchaudio

# Load EnCodec
model = CompressionModel.get_pretrained('facebook/encodec_32khz')

# Load audio
wav, sr = torchaudio.load("audio.wav")

# Ensure correct sample rate
if sr != 32000:
    resampler = torchaudio.transforms.Resample(sr, 32000)
    wav = resampler(wav)

# Encode to tokens
with torch.no_grad():
    encoded = model.encode(wav.unsqueeze(0))
    codes = encoded[0]  # Audio codes

# Decode back to audio
with torch.no_grad():
    decoded = model.decode(codes)

torchaudio.save("reconstructed.wav", decoded[0].cpu(), sample_rate=32000)

`

## Quy trình công việc chung

### Quy trình 1: Quy trình tạo nhạc

`Python
 import torch
 import torchaudio
from audiocraft.models import MusicGen`class MusicGenerator:
    def __init__(self, model_name="facebook/musicgen-medium"):
        self.model = MusicGen.get_pretrained(model_name)
        self.sample_rate = 32000`def generate(self, prompt, duration=30, temperature=1.0, cfg=3.0):
        self.model.set_generation_params(
            duration=duration,
            top_k=250,
            temperature=temperature,
            cfg_coef=cfg
        )

with torch.no_grad():
            wav = self.model.generate([prompt])

return wav[0].cpu()

def generate_batch(self, prompts, duration=30):
        self.model.set_generation_params(duration=duration)

with torch.no_grad():
            wav = self.model.generate(prompts)

return wav.cpu()

def save(self, audio, path):
        torchaudio.save(path, audio, sample_rate=self.sample_rate)

# Usage
generator = MusicGenerator()
audio = generator.generate(
    "epic cinematic orchestral music",
    duration=30,
    temperature=1.0
)
generator.save(audio, "epic_music.wav")

`

### Workflow 2: Xử lý hàng loạt thiết kế âm thanh

`Python
 import JSON
from pathlib import Path
from audiocraft.models import AudioGen
 import torchaudio`def batch_generate_sounds(sound_specs, output_dir):
    """
    Generate multiple sounds from specifications.

Args:
        sound_specs: list of \{"name": str, "description": str, "duration": float}
        output_dir: output directory path
    """
    model = AudioGen.get_pretrained('facebook/audiogen-medium')
    output_dir = Path(output_dir)
    output_dir.mkdir(exist_ok=True)

results = []

for spec in sound_specs:
        model.set_generation_params(duration=spec.get("duration", 5))

wav = model.generate([spec["description"]])

output_path = output_dir / f"\{spec['name']}.wav"
        torchaudio.save(str(output_path), wav[0].cpu(), sample_rate=16000)

results.append({
            "name": spec["name"],
            "path": str(output_path),
            "description": spec["description"]
        })

return results

# Usage
sounds = [
    \{"name": "explosion", "description": "massive explosion with debris", "duration": 3},
    \{"name": "footsteps", "description": "footsteps on wooden floor", "duration": 5},
    \{"name": "door", "description": "wooden door creaking and closing", "duration": 2}
]

results = batch_generate_sounds(sounds, "sound_effects/")

`

### Workflow 3: Bản demo Gradio

`Python
 import gradio as gr
 import torch
 import torchaudio
from audiocraft.models import MusicGen`model = MusicGen.get_pretrained('facebook/musicgen-small')

def generate_music(prompt, duration, temperature, cfg_coef):
    model.set_generation_params(
        duration=duration,
        temperature=temperature,
        cfg_coef=cfg_coef
    )

with torch.no_grad():
        wav = model.generate([prompt])

# Save to temp file
    path = "temp_output.wav"
    torchaudio.save(path, wav[0].cpu(), sample_rate=32000)
    return path`demo = gr.Interface(
    fn=generate_music,
    inputs=[
        gr.Textbox(label="Music Description", placeholder="upbeat electronic dance music"),
        gr.Slider(1, 30, value=8, label="Duration (seconds)"),
        gr.Slider(0.5, 2.0, value=1.0, label="Temperature"),
        gr.Slider(1.0, 10.0, value=3.0, label="CFG Coefficient")
    ],
    outputs=gr.Audio(label="Generated Music"),
    title="MusicGen Demo"
)

demo.launch()

`

## Tối ưu hóa hiệu suất

### Tối ưu hóa bộ nhớ

`Python

# Use smaller model
model = MusicGen.get_pretrained('facebook/musicgen-small')

# Clear cache between generations
torch.cuda.empty_cache()

# Generate shorter durations
model.set_generation_params(duration=10)  # Instead of 30

# Use half precision
model = model.half()

`

### Hiệu quả xử lý hàng loạt

``` python

# Process multiple prompts at once (more efficient)
descriptions = ["prompt1", "prompt2", "prompt3", "prompt4"]
wav = model.generate(descriptions)  # Single batch

# Instead of
for desc in descriptions:
    wav = model.generate([desc])  # Multiple batches (slower)

`

### Yêu cầu bộ nhớ GPU

| Người mẫu | VRAM FP32 | VRAM FP16 |
|-------|----------|----------|
| musicgen-nhỏ | ~4GB | ~2GB |
| musicgen-medium | ~8GB | ~4GB |
| musicgen-lớn | ~16GB | ~8GB |

## Các vấn đề thường gặp| Vấn đề | Giải pháp |
|-------|----------|
| CUDA OOM | Sử dụng mô hình nhỏ hơn, giảm thời lượng |
| Chất lượng kém | Tăng cfg_coef, lời nhắc tốt hơn |
| Thế hệ quá ngắn | Kiểm tra cài đặt thời lượng tối đa |
| Tạo tác âm thanh | Hãy thử nhiệt độ khác nhau |
| Âm thanh nổi không hoạt động | Sử dụng biến thể mô hình âm thanh nổi |

## Tài liệu tham khảo
- **[Advanced Usage](https://GitHub.com/NousResearch/Hermes-agent/blob/main/skills/mlops/models/audiocraft/references/advanced-usage.md)** - Đào tạo, tinh chỉnh, triển khai
- **[Troubleshooting](https://GitHub.com/NousResearch/Hermes-agent/blob/main/skills/mlops/models/audiocraft/references/troubleshooting.md)** - Các vấn đề thường gặp và giải pháp

## Tài nguyên
- **GitHub**: https://GitHub.com/facebookresearch/audiocraft
- **Giấy (MusicGen)**: https://arxiv.org/abs/2306.05284
- **Giấy (AudioGen)**: https://arxiv.org/abs/2209.15352
- **HuggingFace**: https://huggingface.co/facebook/musicgen-small
- **Bản demo**: https://huggingface.co/spaces/facebook/MusicGen