data_pipeline/ssl/extract_xlsr.py

import torchaudio
import glob
import numpy as np
import torch
import torch.multiprocessing as mp
import torchaudio
import joblib
import librosa
import threading
import math
import numpy as np
import itertools
from tqdm import tqdm
from pathlib import Path
import random
import os
from xlsr300m import WAV2VEC2_XLSR_300M
import sys

LOGGING_INTERVAL = 10
OFFSET = 0
BATCH_SIZE = 1


INPUT_DIR = sys.argv[1]
OUTPUT_DIR = sys.argv[2]
FEATURE_OUTPUT_DIR = os.path.join(OUTPUT_DIR, "xlsr_18l")
KM_OUTPUT_DIR = os.path.join(OUTPUT_DIR, "xlsr_18l_512")
NUM_THREADS = int(sys.argv[3])

os.environ["OMP_NUM_THREADS"] = "4"

os.makedirs(FEATURE_OUTPUT_DIR, exist_ok=True)
os.makedirs(KM_OUTPUT_DIR, exist_ok=True)

class ApplyKmeans(object):
    def __init__(self, km_path):
        self.km_model = joblib.load(km_path)
        self.C_np = self.km_model.cluster_centers_.transpose()
        self.Cnorm_np = (self.C_np ** 2).sum(0, keepdims=True)

        self.C = torch.from_numpy(self.C_np)
        self.Cnorm = torch.from_numpy(self.Cnorm_np)
        if torch.cuda.is_available():
            self.C = self.C.cuda()
            self.Cnorm = self.Cnorm.cuda()

    def __call__(self, x):
        if isinstance(x, torch.Tensor):
            dist = (
                x.pow(2).sum(1, keepdim=True)
                - 2 * torch.matmul(x, self.C)
                + self.Cnorm
            )
            return dist.argmin(dim=1).cpu().numpy()
        else:
            dist = (
                (x ** 2).sum(1, keepdims=True)
                - 2 * np.matmul(x, self.C_np)
                + self.Cnorm_np
            )
            return np.argmin(dist, axis=1)

def inference(rank, queue: mp.Queue):
    ext_token = False
    # def get_audio(path):
    #     sample, sr = torchaudio.load(path)
    #     sample = torchaudio.functional.resample(sample, sr, 16000).reshape(-1)
    #     return sample
    #apply_kmeans = ApplyKmeans("km_512_youtube1")
    apply_kmeans = ApplyKmeans("km_xlsr_512_18l")

    def get_audio(path):
        wav, _ = librosa.load(path, sr=16000)

        wav = torch.FloatTensor(wav)
        return wav

    # device = torch.device("cuda", OFFSET + rank)
    #device = torch.device("cpu")
    device = torch.device(f"cuda:{rank}")

    # bundle=torchaudio.pipelines.WAV2VEC2_XLSR_300M
    bundle = WAV2VEC2_XLSR_300M
    bundle._normalize_waveform=False
    xlsr=bundle.get_model(dl_kwargs={'model_dir':'.','map_location':'cpu'})
    #xlsr=bundle.get_model(dl_kwargs={'model_dir':'/datablob/v-ziqianning/ckpts','map_location':'cpu'})
    xlsr = xlsr.eval()
    xlsr = xlsr.requires_grad_(False)
    xlsr = xlsr.to(device)


    while True:
        paths = queue.get()
        if paths is None:
            break

        #try:
        #    if os.path.exists(FEATURE_OUTPUT_DIR / f"{file_names[0]}.npy"):
        #        _ = np.load(FEATURE_OUTPUT_DIR / f"{file_names[0]}.npy")
        #        continue
        #except:
        #    pass

        try:
            file_names = [path.stem for path in paths]
            if os.path.exists(os.path.join(FEATURE_OUTPUT_DIR, f"{file_names[0]}.npy"))\
                and os.path.exists(os.path.join(KM_OUTPUT_DIR, f"{file_names[0]}.npy")):
                continue
            samples = [get_audio(path) for path in paths]
            lengths = [math.ceil(sample.shape[-1] / 320) for sample in samples]
            batched_samples = torch.nn.utils.rnn.pad_sequence(
                samples, batch_first=True
            ).to(device)


            #features = xlsr.extract_features(batched_samples,lengths=None,num_layers=6)[0][-1]
            features = xlsr.extract_features(batched_samples,lengths=None,num_layers=18)[0][-1]
            # [batch, frame, dim] of layer

            b, t, d = features.shape

            for feature, file_name, length in zip(
                features.cpu().numpy(), file_names, lengths
            ):                
                np.save(os.path.join(FEATURE_OUTPUT_DIR, f"{file_name}.npy"), feature) # [:length, :])
                km_feat = apply_kmeans(feature)
                np.save(os.path.join(KM_OUTPUT_DIR, f"{file_name}.npy"), km_feat) # [:length, :])

        except Exception as e:
            print(f"{e} in {paths} with longest length of {max(lengths)}")








def setInterval(interval):
    def decorator(function):
        def wrapper(*args, **kwargs):
            stopped = threading.Event()

            def loop():  # executed in another thread
                while not stopped.wait(interval):  # until stopped
                    function(*args, **kwargs)

            t = threading.Thread(target=loop)
            t.daemon = True  # stop if the program exits
            t.start()
            return stopped

        return wrapper

    return decorator


last_batches = None


@setInterval(LOGGING_INTERVAL)
def QueueWatcher(queue, bar):
    global last_batches
    curr_batches = queue.qsize()
    bar.update(last_batches-curr_batches)
    last_batches = curr_batches


if __name__ == "__main__":
    mp.set_start_method('spawn',force=True)

    gpu_num = torch.cuda.device_count()


    print(f"Running with {NUM_THREADS} threads and batchsize {BATCH_SIZE}")
    processes = []
    queue = mp.Queue()
    for thread_num in range(NUM_THREADS):

        rank = thread_num % gpu_num
        p = mp.Process(target=inference, args=(rank, queue))
        p.start()
        processes.append(p)

    accum = []
    tmp_file = []
    
    # path_list = []
    # for scp in glob.glob(os.path.join(INPUT_DIR, '*.lst')):
    #     tmp = [x.split('\t')[0] for x in open(scp).readlines()]
    #     print(len(tmp))
    #     path_list = list(set(path_list) | set(tmp))
    #     print(len(path_list))



    if os.path.isfile(INPUT_DIR):
        path_list = [x.strip() for x in open(INPUT_DIR).readlines()]
    else:
        path_list = glob.glob(os.path.join(INPUT_DIR, '*.wav'))

    # for file in tqdm(INPUT_DIR.glob("**/*.wav")):
    for file in tqdm(path_list):
        file = Path(file)
        # if not input_guard(file):
        #     continue
        accum.append(file)
        if len(accum) == BATCH_SIZE:
            queue.put(accum.copy())
            accum.clear()
        # tmp_file.append(file.as_posix()+'\n')

    for _ in range(NUM_THREADS):
        queue.put(None)

    last_batches = queue.qsize()
    bar = tqdm(total=last_batches, desc="ssl")
    queue_watcher = QueueWatcher(queue, bar)
    for p in processes:
        p.join()
    queue_watcher.set()

    #f_w = open(FILE_LIST,'a')
    #f_w.writelines(tmp_file)
    #f_w.close()