parquet_000000000.tar中的特征是如何提取的

[LilHOliang]

谢谢作者的开源工作，想问一下examples/music_generation/data/samples/parquet/parquet_000000000.tar里面的semantic_token 和acoustic_token是怎么提取的到的呢，如果我需要生成其它类型的音乐的话

[iris2c]

谢谢作者的开源工作，想问一下examples/music_generation/data/samples/parquet/parquet_000000000.tar里面的semantic_token 和acoustic_token是怎么提取的到的呢，如果我需要生成其它类型的音乐的话

可以参考examples/music_generation/run.sh这里的stage 1和2来提取

[fetimo]

Hi @iris2c , I'm also interested in this and have looked into run.sh. I've also tried running it with the MusicCaps dataset but that dataset does not include wav.scp and I'm unsure how to generate this. Do you have any tips on how to create our own acoustic and semantic tokenizers for our own music sources for use with InspireMusic?

I really appreciate all the work that has gone into this 🥇

[fetimo]

I've created my own solution, not 100% sure if it's correct as I'm yet to use it properly but this might help others that come across this. A script to generate wave.scp and text from a directory containing .wav files. It splits them depending on how much you want to use for training and how much for cross-validation. Note that you still need to go in and actually label them properly (intro, outro, lyrics etc).

#!/usr/bin/env python3

import soundfile as sf
from pathlib import Path
import random
import argparse
import logging

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')


def get_wav_files(input_dir):
	return sorted([f for f in input_dir.glob('*.wav') if f.is_file()])

def split_files(wav_files, train_ratio, seed=42):
	random.seed(seed)
	random.shuffle(wav_files)
	n_train = int(len(wav_files) * train_ratio)
	return wav_files[:n_train], wav_files[n_train:]
	return wav_files, wav_files

def process_split(wav_files, split, output_base, dataset_name, chunk_length, section, typ, text):
	output_dir = output_base / f"{dataset_name}_{split}"
	output_dir.mkdir(parents=True, exist_ok=True)
	wavscp_lines = []
	text_lines = []

	for wav_path in wav_files:
		audio, sr = sf.read(wav_path)
		samples_per_chunk = int(chunk_length * sr)
		total_samples = len(audio)
		num_chunks = (total_samples + samples_per_chunk - 1) // samples_per_chunk  # ceil division

		for i in range(num_chunks):
			start_sample = i * samples_per_chunk
			end_sample = min((i + 1) * samples_per_chunk, total_samples)
			chunk_audio = audio[start_sample:end_sample]

			utterance_id = f"{wav_path.stem}_{i:03d}"
			out_wav = output_dir / f"{utterance_id}.wav"
			sf.write(out_wav, chunk_audio, sr)

			wavscp_lines.append(f"{utterance_id}\t{out_wav.resolve()}\n")

			t0 = i * chunk_length
			t1 = t0 + (end_sample - start_sample)/sr
			desc = f"<|{t0:.1f}|><|{section}|><|{typ}|><|{text}|><|{t1:.1f}|>"
			text_lines.append(f"{utterance_id} {desc}\n")

	# Write wav.scp and text file
	with open(output_dir / 'wav.scp', "w") as f:
		f.writelines(wavscp_lines)
	with open(output_dir / 'text', 'w') as f:
		f.writelines(text_lines)

	logging.info(f"Processed {len(wavscp_lines)} chunks in {output_dir}")


def main(args):
	input_dir = Path(args.input_dir)
	output_base = Path(args.output_base)

	wav_files = get_wav_files(input_dir)
	logging.info(f"Found {len(wav_files)} WAV files in {input_dir}")

	train_files, dev_files = split_files(wav_files, args.train_ratio, args.random_seed)

	logging.info(f"Total files: {len(wav_files)}, Train: {len(train_files)}, Dev: {len(dev_files)}")
	process_split(train_files, 'train', output_base, args.dataset_name, args.chunk_length, 
	             args.section, args.typ, args.text)
	process_split(dev_files, 'dev', output_base, args.dataset_name, args.chunk_length, 
	             args.section, args.typ, args.text)


if __name__ == "__main__":
	parser = argparse.ArgumentParser(description="Prepare dataset chunks for training")
	parser.add_argument('--input_dir', type=str, default='data/music',
	                    help='Directory containing WAV files')
	parser.add_argument('--output_base', type=str, default='data',
	                    help='Base directory for output files')
	parser.add_argument('--dataset_name', type=str, default='music',
	                    help='Name of the dataset')
	parser.add_argument('--chunk_length', type=int, default=15,
	                    help='Length of each chunk in seconds')
	parser.add_argument('--train_ratio', type=float, default=0.9,
	                    help='Ratio of files to use for training (e.g., 0.9 = 90% train, 10% dev)')
	parser.add_argument('--random_seed', type=int, default=42,
	                    help='Random seed for file splitting')
	parser.add_argument('--section', type=str, default='chorus',
	                    help='Section label for the audio')
	parser.add_argument('--typ', type=str, default='music',
	                    help='Type label for the audio')
	parser.add_argument('--text', type=str, default='N/A',
	                    help='Text label for the audio')

	args = parser.parse_args()

	main(args)